# Activate Projects
Source: https://landinglens.docs.landing.ai/activate-projects



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

A project must be “active” before you can [download models](./download-models) from it or deploy models from it using [LandingEdge](./landingedge/landingedge-overview) or [Docker Deployment](./landingedge/docker-deploy).

Once a project is activated, you can download an unlimited number of models from it. You are NOT limited to one model per project. This is especially useful if you’re iterating on a model and want to test out multiple versions by deploying each one in a real-world environment.

You can activate a project at the organization level. Or, if you try to download a model and the project hasn’t been activated yet, you will be prompted to activate the project.

<Info>If you [delete a project](./delete-projects) that's activated, it will automatically be removed from the Activate Projects page.</Info>

## Number of Projects That You Can Download From

Each pricing plan has a maximum number of projects that can be active at the same time.

* **Free**: 1 project
* **Visionary**: 3 projects
* **Enterprise**: Starts at 5 projects
* : 5 projects

## If I deactivate a project, can I activate another in its place?

By default, most accounts can deactivate a project and then activate another in its place. However, some contracts with  do not allow "swapping out" active projects. If you have questions about your organization's ability to deactivate and reactivate projects, contact [support@landing.ai](mailto:support@landing.ai).

## Activate Projects

<Info>Only Admins and Owners can access the **Active Projects** page to activate and deactivate projects. Collaborators can activate a project if they attempt to [download a model](./download-models) from a project that isn't active. (In , any user can access the **Active Projects** page.)</Info>
To activate projects on the **Active Projects** page:

1. Click the **User Menu** and select **Active Projects**.
   <img alt="activate_project_1(1)" />
2. Click **Activate a Project**.
   <img alt="activate_project_2" />
3. Click the project you want to activate.
4. For Free and Visionary plans, downloaded models can only be used for noncommercial purposes. If you’re on one of those plans, select the check box agreeing to the terms for noncommercial use.
5. Click **Activate**.
   <img alt="activate_project_3" />
6. The project is activated and displays in the **Active Projects** tab. You can now [download models](./download-models) from this project.
   <img alt="activate_project_4" />

## Deactivate Projects

You can deactivate a project at any time. When a project is deactivated, you will no longer be able to download models from the project (unless the project is later re-activated).

To deactivate a project:

1. Click the **User Menu** and select **Active Projects**.
   <img alt="activate_project_1(1)" />
2. Click **Remove** next to the project you want to deactivate. The model is deactivated.
   <img alt="deactivate_project" />


# Documentation for Agentic Document Extraction
Source: https://landinglens.docs.landing.ai/ade



Agentic Document Extraction (ADE) is a document intelligence tool from . This tool is separate from  and LandingEdge.

Documentation for ADE is available here: [https://docs.landing.ai/](https://docs.landing.ai/).


# Agreement-Based Labeling
Source: https://landinglens.docs.landing.ai/agreement-based-labeling



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

<iframe title="YouTube video player" />

LandingLens offers the ability to create and manage a [Label Book](./manage-label-book). A Label Book is a living document to help guide users on how to properly label various categories of Classes. Now, you might be asking:

* How do we measure the consistency of labels across multiple users?
* How do we ensure that only clean, accurate labels will be added to images?

The answer is Agreement-Based Labeling. **Agreement-Based Labeling** is the concept of allowing multiple users to label the same set of images to analyze the consistency of their labels. This method allows you to identify the areas where users may need more direction with labeling.

For example, let's say you have these Classes for Labelers to choose from:

* Scratch
* Rub Mark
* Crack

Now take a look at the image below. Some Labelers may choose to label the identified area as a Scratch, while others may select Rub Mark or Crack. To help clarify this ambiguity, you can use Agreement-Based Labeling, then update your Label Book accordingly.

<img alt="Image" />

<Info>Classification projects support Labeling Tasks, but not Agreement-Based Labeling.</Info>
<Info>Visual Prompting and Anomaly Detection projects do not support Labeling Tasks and Agreement-Based Labeling.</Info>

## Agreement-Based Labeling Workflow

This is how Agreement-Based Labeling works:

1. Send a [Labeling Task](./agreement-based-labeling#send-labeling-tasks) to two or three users. This allows multiple users to label the same sets of images.
2. After the images have been labeled, LandingLens:
   * Calculates the similarities between the labels. This calculation is called the **Agreement Score**.
   * Ranks the images by Agreement Score, from lowest (least agreed and most confusion) to highest (most agreed and least confusion).
3. You can then [review the labels](./agreement-based-labeling#review-submitted-labeling-tasks) and accept or reject them. When you reject a label, you can provide feedback to the Labeler. To prevent issues in the future, add clarifying information to the [Label Book](./manage-label-book).
   <img alt="Agreement-Based Labeling" />

## Labeling Tasks

Let's say you labeled some images, and you want to compare your findings with another user. To do this, you can send a **Labeling Task** to that user.

LandingLens sends images in batches of 20 until all images have been reviewed by the required number of Labelers. However, if you send a Labeling Task with fewer than 20 images, LandingLens automatically divides those images into smaller batches. Let's explore how LandingLens sends images in an example.

Let's say you create a Labeling Task with these settings:

* The Labeling Task has 30 images.
* Two Labelers are required to label each image.

You then send the Labeling Task to these three Labelers: Anna, Cameron, and Eliza. The following steps will occur:

1. LandingLens divides the 30 images into two batches:
   * **Batch One**: Includes the first 20 images
   * **Batch Two**: Includes the remaining 10 images
2. LandingLens sends **Batch One** to two of the Labelers. (Let's say, Anna and Cameron.)
3. Since two Labelers are required to label each image, the first person to complete their labels will be sent\*\* Batch Two\*\* . For example, if Cameron finishes labeling Batch One before Anna, then he will be sent Batch Two.
4. LandingLens sends **Batch Two** to the third Labeler. (In this case, Eliza.)
   <img alt="Assigned Images" />

<Info>You can only send Labeling Tasks to Members who have been [invited](./public-and-private-projects) to your project.</Info>
<Info>One set of images can only be added to one Labeling Task at a time; you cannot have the same set of images in multiple Labeling Tasks.</Info>

### Send Labeling Tasks

1. Open the project.
2. Select the images you labeled.
3. Click **Options** in the action bar near the bottom of the screen and select **Create Labeling Task**. (You may need to scroll to see this option.)
   <img alt="Create Labeling Task(1)" />
4. Enter a brief, descriptive name for the Labeling Task in the **Task Name** field.
5. Select how many Labelers you want to label the images from the drop-down menu. For example, if you want two Labelers to label images, select **2**.
6. If you've already labeled some images, you can choose whether to display (carry over) those existing labels. Select **No** to remove the labels, or select **Yes** to display the labels.
7. Select the Labelers you want to send a Labeling Task to from the **Assign Labelers** drop-down menu. To add multiple users, click the **+** icon.
8. Click **Create Task**. An email is sent to the Labelers, notifying them of the task.
   <img alt="Send Labeling Task" />

### Events That Occur After Labeling Tasks Are Sent

After a Labeling Task is sent, these events occur:

* The **New Labeling Task** email is sent to the Labeler. This email includes a link to the requested images.
* Images in a Labeling Task have the status **In Task**.
  <img alt="In Task Status" />
* Images in a Labeling Task can only be labeled by the requested Labelers. (The requested Labelers can only label images using the link from the **New Labeling Task** email.)
  <img alt="Image Is In a Labeling Task" />

### Labeling Tasks for Segmentation Projects

Labeling Tasks in Segmentation projects are assigned to users in batches of five images. For example, if you create a Labeling Task with 10 images and assign it to a user, that user will get two batches of five images each.

<img alt="batches" />

When the user opens a Labeling Task, they will see five images. When they submit that batch, the second batch of five images becomes available.

<img alt="LabelTask_Seg" />

Limiting each batch to five images allows LandingLens to process each batch quickly.

## Assign Additional Users to Labeling Tasks

1. Open the project.
2. Click **Tasks** in the left side panel.
3. On the **Reviewing** tab, click the vertical ellipses button and select **Assign To**.
   <img alt="Assign Labeling Task" />
4. Click the **+** icon.
   <img alt="Add" />
5. Enter the name of the user you want to assign the Labeling Task to. (Remember, you can only invite users who have been invited to your project.)
6. Click **Assign**.
   <img alt="Assign Another Labeler" />

## View and Submit Labeling Tasks

If a user has sent you a Labeling Task, you will receive the **New Labeling Task** email.

To view an assigned Labeling Task:

1. Click the link in the **New Labeling Task** email.
2. The task opens. Label the images.
3. After you've labeled all images, click **Submit** to share your labels.
   <img alt="Submit Labeling Task" />

## Review Submitted Labeling Tasks

After all the Labelers have submitted their Labeling Task, you will receive the **Task \[#] Has Labels Ready for Your Review** email. This email includes a link to the labeled images. Click this link to compare the labels. You can also click the **Review** button on the **Tasks** page to compare the labels.

<img alt="Review" />

The **Review Task** page with the labeled images will display. This page includes several settings to help you review the labels. The table below describes these settings.

<img alt="Review" />

| Number | Settings                       | **Description**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| ------ | ------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| 1      | Review Metrics                 | <ul><li>**In Review**: The number of labeled images that have yet to be reviewed.</li><li>**Accepted**: The number of images that have been manually accepted. </li><li>**Rejected**: The number of images that have been auto-rejected or manually rejected. Images are auto-rejected based on the Agreement Threshold. (See number 3.)</li></ul>                                                                                                                                                                                                                                                                                                     |
| 2      | Hot Keys / Label Book / Submit | <ul><li>**Hot Keys**: LandingLens offers a variety of hot keys (or keyboard shortcuts) to help speed up the process of reviewing tasks. This button displays those hot keys.</li><li>**Label Book**: Opens the Label Book. This is useful so you can update the entries. </li><li>**Submit**: After you've reviewed all the images, you can submit them to complete the review.</li></ul>                                                                                                                                                                                                                                                              |
| 3      | Agreement Threshold            | By default, LandingLens calculates the similarities between all labels. This calculation is called the **Agreement Score**. The platform determines the Agreement Score based on the overlap of the Labelers' labels. For example, if the labels overlap by 50%, then the Agreement Score will be .50. <br /><br />You can adjust the required Agreement Score that images must have by changing the **Agreement Threshold**<sup>1</sup>. For example, let's say the Agreement Threshold is set to .80. This means that the Labelers' labels must overlap by 80% to be approved.<sup>2</sup>                                                           |
| 4      | Image Agreement                | The Agreement Score for the opened image.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| 5      | Settings                       | The **Settings** icon allows you to adjust the brightness and contrast of the image. This allows you to brighten images that were taken at night, for example.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| 6      | Labelers' Labels               | By default, the labels of all Labelers display on the image. You can select a Labeler to see their label only. This is useful if you want to accept the labels of a single Labeler.                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| 7      | Agreement Sort                 | By default, images are sorted by Agreement Score, from lowest (least agreed and most confusion) to highest (most agreed and least confusion). You can click the Agreement arrow to sort from the highest to lowest Agreement Score instead.                                                                                                                                                                                                                                                                                                                                                                                                            |
| 8      | Action buttons                 | <ul><li>**Add Image to Label Book**: There may be times when a Labeler is unsure how to label an image because the objects to identify overlap or are close together. You can add these types of images to the Label Book to help users in these rare cases.</li><li>**Add Metadata**: Tag images by adding metadata. Tagging images can help users locate specific images. Example tags: rare-case, ambiguous-case.</li><li>**Review Notes**: Leave feedback for the Labelers to help them understand why you rejected an image.</li><li>**Accept / Reject**: Accept or reject the labels of an image.</li><li>**Edit**: Update the labels.</li></ul> |

<Info>1. If there is only one Labeler assigned to a task, you will not see the Agreement Threshold.</Info>
<Info>2. A high Agreement Score does not necessarily mean that the labels are correct. It is still recommended to review these labels.</Info>


# Anomaly Detection
Source: https://landinglens.docs.landing.ai/anomaly-detection



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

<iframe title="YouTube video player" />

The **Anomaly Detection** project type is used to identify deviations from the norm, especially when you have few images of "abnormal" cases. These projects have two built-in classes: **Normal** and **Abnormal**, which you assign to images.

Anomaly Detection models train on Normal images to learn their patterns. The model then flags any deviations as potential anomalies.

<Info>Classes can't be added, deleted, or changed in Anomaly Detection projects. The available classes are Normal and Abnormal.</Info>

<Info>Using the LandingAI Python library with Anomaly Detection projects isn’t supported.</Info>

## When to Use Anomaly Detection

Use Anomaly Detection when detecting any deviation from the norm is the primary goal, or when you have few images of "abnormal" cases.

Anomaly Detection is useful in scenarios such as:

* **Manufacturing**: You’re manufacturing hoses and need to stop the production line if a defect—such as a tear, puncture, or streak—is detected. The presence of a defect matters more than its specific type.
* **Medical imaging**: You’ve automated chest X-ray reviews and want to alert a clinician whenever an anomaly—such as an infection, tumor, or fracture—is detected. This allows the clinician to investigate further.
* **Fire and smoke detection**: You’re analyzing security camera footage and need to detect the presence of smoke or flames.
* **Agriculture and food sorting**: You’re sorting produce on a production line and need to identify items that deviates from the expected quality—such as bruised apples, misshapen tomatoes, or contaminated grains.
* **Retail and packaging**: You’re inspecting product packaging at fulfillment centers or warehouses before shipping, or before placing on shelves in retail stores. You want to ensure that products and packaging are intact.

## Unsupervised Learning: Training and Splits for Anomaly Detection

Anomaly Detection models in LandingLens use **unsupervised learning**, meaning they learn patterns in data without predefined classes like those used in supervised learning. However, in LandingLens, you still label images as Normal or Abnormal—this is important for how the data is split during model training.

When training an Anomaly Detection model, only images labeled as "Normal" are included in the Train set. The model learns the patterns and characteristics of normal images without being explicitly told what an anomaly looks like. Once trained, the model is evaluated using both Normal images and Abnormal images in the Dev and Test sets to assess its ability to detect anomalies.

For more information about how and why LandingLens splits data, go to [Splits](./splits).

## Model Architecture

The LandingLens Anomaly Detection architecture uses a reverse distillation (RD) paradigm with 160 million parameters.

## How Many "Normal" and "Abnormal" Images Should I Include?

The optimal number of images depends on the complexity of your use case. In general, the more complex the use case, the more images you should use for model training.

Use the guidelines below as a starting point and adjust if needed.

**Normal: Start with 50 Normal images.** These should include a mix of:

* **Ideal conditions (10+ images)**: Images that represent the best-case scenario—clean, well-lit, perfectly positioned, etc.
* **Natural variation (10+ images)**: Images that still meet your definition of Normal but include acceptable variations like lighting changes, minor cosmetic differences, or slight differences in positioning.

**Abnormal: Use at least 1, but ideally 10+**:

* Include at least 1 Abnormal image in the Dev set to help the model set a threshold for detecting anomalies and to generate more meaningful evaluation metrics.
* However, using 10 or more Abnormal images will further improve threshold tuning and lead to more meaninful model metrics.

For more best practices, go to [Curate High-Quality Datasets](./curate-high-quality-datasets). Anomaly Detection models can be trained with a maximum of 1,000 labeled images.

## Best Practice: Use a Consistent Background

Anomaly Detection analyzes the entire image, so use a consistent background across your training and inference images. Otherwise, the model might flag different backgrounds as anomalies.

This is an example of images with consistent backgrounds:

<img alt="Consistent Backgrounds" />

This is an example of images with inconsistent backgrounds:

<img alt="Inconsistent Backgrounds" />

## Label Images at Upload

1. Open the Anomaly Detection project you want to upload images to.
2. Perform one of the following actions:
   * If you do *not* have any images already uploaded to your project, click the **Drop to Upload** area.
     <img alt="AD_upload_no_images" />
   * If you already have images uploaded to your project, click the **Upload** icon.
     <img alt="AD_upload_images_button" />
3. Select or drag-and-drop "normal" images to the **Upload Normal Images**tile. LandingLens displays a preview of the images and their respective classes.
   <img alt="AD_upload_images_1" />
4. If you have any "abnormal" images, select or drag-and-drop them to the **Upload Abnormal Images** tile. LandingLens displays a preview of the images and their respective classes.
5. Click **Upload**. LandingLens uploads the images and classifies them according to their folder titles.
   <img alt="AD_upload_images_2" />

## Add Labels to Images After Upload

To add or change a label for an image, select "Normal" or "Abnormal" from the drop-down menu at the bottom left corner of the image.

<img alt="AD_label_image" />

## Anomaly Detection Workflows

An Anomaly Detection model identifies defects or deviations from the norm. You can use this model on its own, or as part of a model chain. Model chaining is the processs of using the output of one model as the input for another. Chaining models allows you to combine the strengths of different models to meet the specific needs of your use case.

The right workflow depends on your use case and goals. This section gives an overview of three common worfklows.

### Workflow 1: Run Anomaly Detection On Its Own

Use Anomaly Detection on its own when you don’t have examples of defects. This approach works well in these use cases:

* New product lines where defects haven't occurred yet.
* Stable, mature production lines with good quality control, where defects are rare or previously unseen.

### Workflow 2: Run Anomaly Detection Before Another Model

Run the Anomaly Detection model first when you want to quickly filter out Normal images and focus further analysis on potential defects. This workflow speeds up processing by eliminating Normal images early, reducing the workload on the second model.

1. Run the Anomaly Detection model to classify images as Normal or Abnormal.
2. Send only the Abnormal images to an Object Detection or Segmentation model.
3. The second model predicts the defect type and location.

<img alt="AnomalyDetection_Workflow_AD_first_1" />

### Workflow 3: Run Anomaly Detection After Another Model

Run the Anomaly Detection model second when you want to catch issues that the first model might miss. This workflow helps reduce the overall rate of False Negatives and improves the Recall score. This approach is especially useful for unknown or rare defects that aren't well-represented in your training data.

1. Run an Object Detection or Segmentation model to identify known defect types.
2. Send images with no detected defects to the Anomaly Detection model.
3. The Anomaly Detection model flags any unusual patterns that weren’t covered by the first model.

<img alt="AnomalyDetection_Workflow_AD_second_1.png" />


# API Keys
Source: https://landinglens.docs.landing.ai/api-key



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✖</span></td>
    </tr>
  </tbody>
</table>

You must use an API Key to run inference. An API key allows LandingLens to authenticate requests to run inference using the Models you’ve created. This prevents non-authorized users from accessing your Models.

## Changes to API Authentication

Up until June 30, 2023, LandingLens required both an API Key and API Secret to be used to run inference. After evaluating our user experience and current industry standards, we decided to eliminate the use of the API Secret. As of , LandingLens generates and requires only an API Key.

<img alt="api_new" />

If you generated API Key and API Secret pairs before , those credentials will continue to be valid. Creating API Keys will not override your existing API Key and API Secret.

If you choose to use the legacy API Key and API Secret, you must use them together; you won’t be able to enter only the API Key.

Additionally, any API calls or LandingEdge Inspection Points using the legacy API credentials will continue to work, and aren’t affected by this change. No action is needed.

### View Legacy API Credentials

If you generated API credentials before , you can view those at the bottom of the API page:

1. Click the **User Menu** and select **API Key**.
   <img alt="api_key_user_1(1)" />
2. The existing credentials display in the **Legacy API Key & Secret** section.
   <img alt="api_legacy" />

### Authenticate in LandingEdge

To support legacy API credentials, LandingEdge will continue to have both an **API Key** field and an **API Secret** field.

If you only have the API Key, enter it in the **API Key** field. Then, if using LandingEdge v2.5.5 or later, leave the **API Secret** field blank. If using an earlier version, enter a minimum of one alphanumeric character in the **API Secret** field.

<img alt="api_key_le" />

### Authenticate via API

When you generate an API call from the **Deploy** page beginning on , it includes a placeholder for your API Key, but not one for an API Secret.

```bash theme={null}
curl --location --request POST 'ENDPOINT' \
     --header 'Content-Type: multipart/form-data' \
     --header 'apikey: YOUR_APIKEY' \
     --form 'file=@"YOUR_IMAGE"'
```

If you want to use your legacy API credentials, you have two options:

You can click the hyperlink in this text on the **Deploy** page: If you have a legacy API Key and Secret, click here to copy the cURL command.

<img alt="generate_legacy_api_call" />

```bash theme={null}
curl --location --request POST 'ENDPOINT' \
     --header 'Content-Type: multipart/form-data' \
     --header 'apikey: YOUR_APIKEY' \
     --header 'apisecret: YOUR_APISECRET' \
     --form 'file=@"YOUR_IMAGE"'
```

## Create Multiple API Keys

You can create multiple API Keys. This gives you more flexibility and control over who can run inference with your deployed Models.

For example, let's say that you are running a Beta Test, and you have a group of testers running inference. You can generate an API Key and give it only to those testers. After the Beta Test is complete, you no longer want those testers to have the option to run inference on that Model anymore. To secure the Model, you can [revoke the API Key](#revoke-or-activate-api-key). When the API Key is revoked, anyone attempting to use that API Key won't have access.

## Can Use Any API Key for Any Project in Your Organization

The API Key is valid for all Projects within the same organization in LandingLens. However, you must have access to a Project to use the API Key to run inference in that Project. For more information about accessing Projects, go to [Public and Private Projects](./public-and-private-projects).

If you have more than one organization in LandingLens, the API Keys in one organization aren't valid for another.

## Generate API Keys

<iframe title="YouTube video player" />

1. Click the **User Menu** and select **API Key**.
   <img alt="api_key_user_1(1)" />
2. Click **Create New Key**.
   <img alt="api_key_user_2" />
3. Read the tips about using API Keys in LandingLens.
4. Enter a brief, descriptive name for the API Key in the **Key Name** field.
5. Click **Generate API Key**.
   <img alt="api_key_user_3" />
6. A pop-up window opens, displaying the API Key. You can click the **Copy** icon to copy the API Key, if needed. Click **Done** to close the pop-up window.
   <img alt="api_key_user_4" />

### Access API Keys from the Deploy Page

To access API Keys from the Deploy page:

1. Open a Project that already has an endpoint set up for deployment.
2. Click **Deploy**.
3. Click **View API Key & Secret**.
   <img alt="deploy_view_api" />
4. This opens the API Keys page. Here, you can create, view, and edit API Keys.
   <img alt="api_key_landing" />

## Retrieve API Key

For security, part of the API Key is replaced with asterisks after it's generated. You can see the full API Key for any key you've generated. You can't see API Keys that anyone else (including Admins) has generated.

To retrieve an API Key:

1. Click the **User Menu** and select **API Key**.
   <img alt="api_key_user_1(1)" />
2. Click the **Eye** icon next to your API Key.
   <img alt="api_key_retrieve" />
3. The full API Key displays. The API Key remains unhidden to you until you leave the page.

## Edit API Key Name

You can edit the name of any API Key you've generated. You can't edit an API Key that anyone else (including Admins) has generated.

1. Click the **User Menu** and select **API Key**.
   <img alt="api_key_user_1(1)" />
2. Click the **Actions** icon.
   <img alt="rename_api_1(1)" />
3. Select **Edit Key Name**.
   <img alt="rename_api_2" />
4. Enter the new name.
5. Click **Save** to save your changes and close the pop-up window.
   <img alt="rename_api_3" />

## Revoke or Activate API Key

If you no longer want an API Key to be valid, you can revoke it. An API Key is not valid during that time that it's revoked. You can later re-activate the API Key if you want to use it again.

You can revoke or activate any API Key you've generated. You can't edit an API Key that anyone else (including Admins) has generated.

To revoke or activate an API Key:

1. Click the **User Menu** and select **API Key**.
   <img alt="api_key_user_1(1)" />
2. Click the **Actions** icon.
   <img alt="api_key_revoke_1" />
3. Select either **Revoke** or **Activate**.
   <img alt="api_key_revoke_2" />
4. The new status displays in the **Status** column.
   <img alt="api_key_revoke_3" />

## Delete API Key

You can delete any API Key you've generated. You can't edit an API Key that anyone else (including Admins) has generated.

You must [revoke](/#revoke-or-activate-api-key) an API Key before you delete it.

<Warning>Deleted API Keys can't be restored.</Warning>

1. Click the **User Menu** and select **API Key**.
   <img alt="api_key_user_1(1)" />
2. Click the **Actions** icon.
   <img alt="api_key_delete_1" />
3. Select **Delete**.
   <img alt="api_key_delete_2" />
4. Read the caution on the pop-up window and click **Delete**.


# Create Classes
Source: https://landinglens.docs.landing.ai/api-reference/classes/create-classes

/openapi.json post /v1/projects/{project_id}/classes



# Get Classes
Source: https://landinglens.docs.landing.ai/api-reference/classes/get-classes

/openapi.json get /v1/projects/{project_id}/classes



# Create Deployment
Source: https://landinglens.docs.landing.ai/api-reference/deployment/create-deployment

/openapi.json post /v1/projects/{project_id}/deployments
This endpoint creates a deployment, which is an instance for running a
model and performing predictions.

To create a deployment, you only need to provide a unique name. Upon
successful creation, the endpoint will return an HTTP URL where you can
send requests for predictions (also known as inferences).

The deployment name cannot be changed after creation.

Here's a breakdown of the deployment creation options:

**Model** (Optional): You can either:

- Provide the model data during deployment creation, making it ready to use
immediately.
- Upload a model to the deployment later and then use it for predictions.


**Threshold** (Optional):

- Specify a custom threshold value for your
predictions.
- If not provided, the default value used during model training will be
applied.



# Get Deployments
Source: https://landinglens.docs.landing.ai/api-reference/deployment/get-deployments

/openapi.json get /v1/projects/{project_id}/deployments



# Get Single Deployment
Source: https://landinglens.docs.landing.ai/api-reference/deployment/get-single-deployment

/openapi.json get /v1/projects/{project_id}/deployments/{deployment_id}



# Update Deployment
Source: https://landinglens.docs.landing.ai/api-reference/deployment/update-deployment

/openapi.json put /v1/projects/{project_id}/deployments/{deployment_id}
You can update a deployment by providing one or both of the following:
- A new model to be used for predictions.
- A new threshold value to be used for classifying predictions.

At least one of these values must be provided for a successful update.

Updating the threshold value with a model already deployed has the
following behavior:
- If you specify a new threshold value, it will override the model's
default threshold.
- If you don't specify a new threshold value, the model's default
threshold will be used.

Updating the deployment with a new model affects the threshold value as
follows:
- If you specify a new threshold value along with the new model, the new
threshold will be used.
- If you don't specify a new threshold value, the threshold associated
with the new model will be used.



# Append Metadata To Media List
Source: https://landinglens.docs.landing.ai/api-reference/image/append-metadata-to-media-list

/openapi.json post /v1/projects/{project_id}/images/metadata



# Append Tags To Media List
Source: https://landinglens.docs.landing.ai/api-reference/image/append-tags-to-media-list

/openapi.json post /v1/projects/{project_id}/images/tags



# Get Project Metadata
Source: https://landinglens.docs.landing.ai/api-reference/image/get-project-metadata

/openapi.json get /v1/projects/{project_id}/images/{image_id}



# Replace image metadata
Source: https://landinglens.docs.landing.ai/api-reference/image/replace-image-metadata

/openapi.json post /v1/projects/{project_id}/images/{image_id}/metadata



# Upload Image
Source: https://landinglens.docs.landing.ai/api-reference/image/upload-image

/openapi.json post /v1/projects/{project_id}/images



# Create Metadata
Source: https://landinglens.docs.landing.ai/api-reference/metadata/create-metadata

/openapi.json post /v1/projects/{project_id}/metadata



# Get Project Metadata
Source: https://landinglens.docs.landing.ai/api-reference/metadata/get-project-metadata

/openapi.json get /v1/projects/{project_id}/metadata



# Update Metadata
Source: https://landinglens.docs.landing.ai/api-reference/metadata/update-metadata

/openapi.json post /v1/projects/{project_id}/metadata/{metadata_id}



# Get Model Download Url
Source: https://landinglens.docs.landing.ai/api-reference/model/get-model-download-url

/openapi.json post /v1/projects/{project_id}/models/{model_id}/download



# Get Models
Source: https://landinglens.docs.landing.ai/api-reference/model/get-models

/openapi.json get /v1/projects/{project_id}/models



# Get Single Model
Source: https://landinglens.docs.landing.ai/api-reference/model/get-single-model

/openapi.json get /v1/projects/{project_id}/models/{model_id}



# Create Project
Source: https://landinglens.docs.landing.ai/api-reference/project/create-project

/openapi.json post /v1/projects



# Get Project
Source: https://landinglens.docs.landing.ai/api-reference/project/get-project

/openapi.json get /v1/projects/{project_id}



# Get Projects
Source: https://landinglens.docs.landing.ai/api-reference/project/get-projects

/openapi.json get /v1/projects



# Update Active Project
Source: https://landinglens.docs.landing.ai/api-reference/project/update-active-project

/openapi.json put /v1/projects/{project_id}/active



# Get Snapshot Export
Source: https://landinglens.docs.landing.ai/api-reference/snapshot/get-snapshot-export

/openapi.json get /v1/projects/{project_id}/dataset/snapshots/{snapshot_version}/export



# Get Snapshot Metadata
Source: https://landinglens.docs.landing.ai/api-reference/snapshot/get-snapshot-metadata

/openapi.json get /v1/projects/{project_id}/dataset/snapshots/{snapshot_version}/metadata



# List Snapshots
Source: https://landinglens.docs.landing.ai/api-reference/snapshot/list-snapshots

/openapi.json get /v1/projects/{project_id}/dataset/snapshots



# Post Snapshot Export
Source: https://landinglens.docs.landing.ai/api-reference/snapshot/post-snapshot-export

/openapi.json post /v1/projects/{project_id}/dataset/snapshots/{snapshot_version}/export



# Create Project Tag
Source: https://landinglens.docs.landing.ai/api-reference/tags/create-project-tag

/openapi.json post /v1/projects/{project_id}/tags



# Get Project Tags
Source: https://landinglens.docs.landing.ai/api-reference/tags/get-project-tags

/openapi.json get /v1/projects/{project_id}/tags



# Update Project Tag
Source: https://landinglens.docs.landing.ai/api-reference/tags/update-project-tag

/openapi.json post /v1/projects/{project_id}/tags/{tag_id}



# Auto Split
Source: https://landinglens.docs.landing.ai/api-reference/training/auto-split

/openapi.json post /v1/projects/{project_id}/autosplit



# Create Training Job
Source: https://landinglens.docs.landing.ai/api-reference/training/create-training-job

/openapi.json post /v1/projects/{project_id}/train



# Get Confusion Matrix For All Splits
Source: https://landinglens.docs.landing.ai/api-reference/training/get-confusion-matrix-for-all-splits

/openapi.json get /v1/projects/{project_id}/train/{training_id}/results/confusion-matrix



# Get Metrics Summary For All Splits
Source: https://landinglens.docs.landing.ai/api-reference/training/get-metrics-summary-for-all-splits

/openapi.json get /v1/projects/{project_id}/train/{training_id}/results/metrics



# Get Per Sample Report
Source: https://landinglens.docs.landing.ai/api-reference/training/get-per-sample-report

/openapi.json get /v1/projects/{project_id}/train/{training_id}/results/per-sample-report
Get a download link for the per-sample performance report of a model.

The report is a CSV file with one row per image in the snapshot the model was
trained on, covering every split, and it is the same file the LandingLens web
app offers as a model performance CSV download.

The columns are `Project Name`, `Project Type`, `Image Name`, `Image ID`,
`Split`, `Upload Time`, `Image Width`, `Image Height`, `Model Name`,
`Metadata`, followed by the ground truth and prediction columns for the
project type:

* Classification: `GT_Class`, `PRED_Class`, `Model_Correct`,
  `PRED_Confidence`, `Gt-PRED JSON`
* Anomaly detection: `GT_Class`, `PRED_Class`, `Model_Correct`,
  `Model_Confidence`, `Gt-PRED JSON`
* Object detection: `GT_Class`, `PRED_Class`, `PRED_Class_Confidence`,
  `Class_TotalArea`, `GT-PRED JSON`

Predictions are reported at the threshold saved on the model, which is the
same threshold used by the `results/metrics` and `results/confusion-matrix`
endpoints. Segmentation projects are not supported.

The download link expires; `downloadExpiresAt` is when it does.



# Get Train Archs
Source: https://landinglens.docs.landing.ai/api-reference/training/get-train-archs

/openapi.json get /v1/projects/{project_id}/train/architectures



# Get Training List
Source: https://landinglens.docs.landing.ai/api-reference/training/get-training-list

/openapi.json get /v1/projects/{project_id}/train



# Get Training Status
Source: https://landinglens.docs.landing.ai/api-reference/training/get-training-status

/openapi.json get /v1/projects/{project_id}/train/{training_id}/status



# Name of LandingLens Instance
Source: https://landinglens.docs.landing.ai/app-name



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✖</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

Some SQL commands for managing  require the name of your instance of LandingLens. The name varies between different LandingLens instances. The placeholder for the name of LandingLens in SQL commands is `APP_NAME`.

The processes that require the name of your instance of LandingLens include:

* [Run inference with SQL commands](./run-inference-with-sql-commands)
* [Load images from Snowflake stages](./load-images-from-snowflake)
* [Grant the LLENS\_PUBLIC application role](./llens-public-application-role)
* [Grant LandingLens access to stages](./grant-landinglens-access-to-stages)
* [Suspend and resume the LandingLens app](./credit-management)

## Locate the Name of Your Instance of LandingLens

You can get the name of your instance of LandingLens in Snowsight:

1. Open [Snowsight](https://app.snowflake.com).
2. Go to **Data Products** > **Apps** > **LandingLens Visual AI Platform**.
   <img alt="appName_1" />
3. Click **Launch App**.
   <img alt="appName_2" />
4. The name of your instance of LandingLens displays right after the text **LandingLens Installer for**. For example, in the screenshot below, the name of the instance of LandingLens is **LANDINGLENS\_SNOWFLAKE**.
   <img alt="appName_3" />


# April 2022 Release Notes
Source: https://landinglens.docs.landing.ai/april-2022-release-notes



This version highlights updates below:

* Faster model training helps to improve the model iteration quickly (normally under 10 mins). Available for Object Detection and Segmentation projects only.
* Auto-Tuning for the model training identifies parameters automatically that makes training models easy and optimizes model accuracy
* Simple labeling steps with direct labeling in the Data Browser

For more details, read the sections below.

## Training a Model

Iterate model training and data re-labeling quickly (currently available for the Object Detection and Segmentation Projects). You can train a model directly from the Data Browser.Some important changes to note:

* **Training Speed** training jobs will execute much faster in the Data Browser. Your initial train will require some warm up time however subsequent training will occur in under 10 minutes (oftentimes below 5 minutes).
* **Training Progress** can now be seen by clicking the box on the top right bar. Once the model has started training, it lists an estimated time to complete.
* **Splits** are no longer Metadata. Instead, we have upgraded them to their own object type to allow for greater functionality. We will automatically split 80/20 dev/test. You can manage this per media or change the splits for the entire dataset by clicking the three dots to the right of “Media Split”.

## Direct Labeling in Data Browser

You can now directly label images in the Data Browser, simply select the image from the Data Browser, select the “Label” option on the top left, select a defect type and start labeling.

## OK/NG Image Level Status

Image level status allows you to see whether the image has labels or not. As you label, you’ll see a red “NG” and green “OK” appear on each image.

## Model Performance & Error Analysis

Once your model has trained, you will see the media level performance score at the top right of your browser. It’s important to note that this model is temporary and will be replaced by subsequent models trained in the Data Browser. If the performance is acceptable, you can save the model to the Models section of the platform.Some important changes to note:

* **Error Analysis** takes place directly in the browser. Simply select “Show Predictions” or use the hotkey ‘s’ to view the predicted labels in the grid view. If you click into an image’s focused view, you will see an overlap of both GT labels (solid box) and prediction (dotted box).
* **Prediction Performance Scores** are visible in the focused media viewer at the bottom left. These scores are measured using the IOU of the ground truth and prediction. You can also sort by score using the “View Options” option in the grid overview.
* **Details / Confidence Threshold** can be accessed using the “Details” button to the right of the model score. From here you can access a variety of detailed confusion matrix views as well as see the impact on performance as you adjust the models confidence threshold.
* **Train Custom Models** using the down arrow next to the Train button. You can adjust transforms, augmentation and hyperparameters as you see fit.


# August 2022 Release Notes
Source: https://landinglens.docs.landing.ai/august-2022-release-notes



## New Features

* &#x20;officially launched their Free Trial program for LandingLens.

**Beta Feature**

* Added a new feature called **Run Live** where you can upload images to LandingLens to see predictions in real time. It is recommended to use this feature before deploying your Model so you can see the accuracy of your Model and where (or if) your Model needs to be improved.

\*Beta features are deactivated by default. Please contact your Landing AI sales member if you would like a Beta feature to be activated.

## Improvements

* Improved the user interface (UI) to streamline workflows.
* Improved the speed of Model training.
* Improved the workflow for Model training and error analysis for Classification Projects.

## Bug Fixes

* Fixed issue where the images on the Device Media page were not displaying according to the set filters.
* Fixed issue where the Device Media page was not loading properly.
* Fixed issue where some image thumbnails were not loading properly.
* Fixed issue where edited labels were not being saved.
* Fixed issue where Model deployment was not working.
* Fixed issue where Model training was not working.
* Fixed issue where users could not run Live Predictions.
* Fixed issue where predicted images were not being saved to the Historical Data page.
* Fixed issue where the Models side panel was not loading for Object Detection Projects.
* Fixed issue where "classification" was misspelled in some CLI syntax.
* Fixed issue where LandingEdge was not opening properly.


# Back Up and Restore LandingLens on Snowflake
Source: https://landinglens.docs.landing.ai/back-up-and-restore-landinglens-on-snowflake



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✖</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

In  v1\_2.45 and later, you can back up and restore the LandingLens application.

Having backup versions of the LandingLens application can be helpful if data is deleted that needs to be later recovered. For example, if a project in LandingLens is accidentally deleted, you can restore an earlier version of LandingLens that has that project.

**If the LandingLens application is deleted, restoring a backup file is the only way to recover it.**

## Process Overview

In Snowsight, you [configure how often you want a backup to be saved](./back-up-and-restore-landinglens-on-snowflake#create-backups-of-landinglens) and the maximum number of backups that should be created. LandingLens then automatically creates backup files based on that schedule.

After the maximum number of backup files are created, LandingLens will delete the oldest file when it creates a new file.

You can [restore a backup](./back-up-and-restore-landinglens-on-snowflake#restoring-backups-of-landinglens) by running SQL commands in Snowsight.

## Backup Best Practices

### Should I create backups?

The ability to back up LandingLens allows organizations to comply with their disaster recovery policies.

The need for a backup depends on your organization’s use of LandingLens and how much downtime and data loss is acceptable in the event of a disaster.

If LandingLens backups are not created, Snowflake support may be able to assist with data loss in some situations, but the turnaround time may be longer.

### How often should I create backups?

The backup frequency depends on your organization’s disaster recovery, compliance, and operational needs.

As a guideline, we recommend backing up LandingLens at least once a day.

## Data in Backup Files

The backup files contain:

* Images uploaded to projects
* Models created in projects
* The labeling, training and inference work

## How Does Suspending the LandingLens App Impact Backups?

Backup files are not created when the LandingLens application is suspended. Backup files will continue to be created once the LandingLens app resumes.

For more information about suspending and resuming the app, go to [Snowflake Credit Management](./credit-management).

## Create Backups of LandingLens

You can configure backup files of LandingLens to be automatically saved to a Snowflake stage.

1. Create or identify the Snowflake stage that will store the backup files.
2. Grant LandingLens access to the stage that will store the backups. To do this, go to [Grant LandingLens Access to Stages](./grant-landinglens-access-to-stages). (You can also find the SQL commands in the app in Snowsight here: **Settings** > **Backup Configuration**.)
3. Open Snowsight.
4. Go to **Data Products** > **Apps** > **LandingLens Visual AI Platform**.
5. Click **Launch App**.
6. Click **Settings**.
7. Expand the **LandingLens Configs** section.
8. Enter the location of the stage in the **Backup to stage** field, using this format: `db_name.schema_name.stage_name`.
9. Specify how often you want a backup to be saved by entering a number in the **Every** box and selecting either **Hours** or **Days** from the drop-down menu.
10. Enter the maximum number of backups to save in the **Max backups to keep** field.
11. Click **Save**.
    <img alt="backupToStage_1" />
12. Click **Main**.
13. Click **Refresh Installation**. The installation must be refreshed for the changes to go into effect.
    <img alt="LLSF_refreshInstall_staging" />

## Get Backup Timestamps and Access Backup Files

If you want to [restore a backup](./back-up-and-restore-landinglens-on-snowflake#restoring-backups-of-landinglens) of LandingLens, you will run a SQL command that includes the filename of the backup file.

Backup files use the following naming convention, where `<TIMESTAMP>` is the date and time the file was created: `landinglens-backup-<TIMESTAMP>`.

The timestamp uses the ISO 8601 format: `YYYYMMDDTHHMMSS`. For example, the timestamp `20250128T135104` indicates that the backup file was created on January 28, 2025, at 13:51:04.

To view the backup files so that you can get the timestamp, run the following command:

```bash theme={null}
LIST @<YOUR_DB>.<YOUR_SCHEMA>.<YOUR_STAGE> PATTERN='landinglens-backup-*';
```

Or, you can open Snowsight and navigate to the stage that you’ve selected to save backup files to.

<img alt="backups_stage" />

## Restoring Backups of LandingLens

Before restoring a backup, read this entire section to understand the temporary app downtime and potential for data loss.

### Restoring a Backup Replaces All Current Data

If you restore a backup, any data created in LandingLens after the backup was created will be lost. This includes but is not limited to new projects, uploaded images, and deployments. For example, if you create a project on Tuesday and then restore a backup from Monday, the new project will be lost.

### Restoring a Backup Doesn’t Change the App Version

Restoring a backup doesn’t change the LandingLens app version. For example, if you are using LandingLens v1\_2.47 and restore a backup created in v1\_2.45, your app will remain on v1\_2.47.

### Restore a Backup

The process to restore a backup takes about 15 to 20 minutes. During that time, users will not be able to access LandingLens.

1. If the LandingLens application has been deleted, [re-install](./install-landinglens-in-snowflake) it and [grant it access to the stage](./grant-landinglens-access-to-stages) that has the backup files.
2. Ensure that the LandingLens application is running (in other words, that it is not suspended). To do this:
   1. Open Snowsight.
   2. Go to **Data Products** > **Apps** > **LandingLens Visual AI Platform**.
   3. Click **Launch App**.
   4. Check that each service **Status** is **Ready**, **Done**, or **Present**. If any of the services aren't running, [resume the app](./credit-management).
      <img alt="LLSF_services_ready" />
3. From the **APP\_WIZARD** page, click **Support**.
4. Select the checkbox to acknowledge that running commands here may perform actions that can’t be undone.
5. Expand the **SQL Passthrough** section.
6. Enter the following command in the **SQL Statement** field. Replace these placeholders with your information: `<YOUR_DB>`, `<YOUR_SCHEMA>`, `<YOUR_STAGE>`, and `<TIMESTAMP>`. To get the `<TIMESTAMP>`, go to [Get Backup Timestamps and Access Backup Files](./back-up-and-restore-landinglens-on-snowflake#get-backup-timestamps-and-access-backup-files).
   ```bash theme={null}
   CALL core.restore_backup('@<YOUR_DB>.<YOUR_SCHEMA>.<YOUR_STAGE>/landinglens-backup-<TIMESTAMP>');
   ```
7. Click **Run**.
   <img alt="restore_backup_SQL_passthrough" />
8. Once the process is complete, the following message displays.
   ```bash theme={null}
   **Restore from backup @<YOUR_DB>.<YOUR_SCHEMA>.<YOUR_STAGE>/landinglens-backup-<TIMESTAMP> complete!
   ```

### Check the Status of the Restore Process

If you’ve started the process to restore a backup file, you can check the status by running this command:

```bash theme={null}
CALL core.check_logs('backupmanager.restore_backup', 
'0', 'backupmanager-app-lndsvc');
```

## Application Backups (If No Backup Location Is Set)

If a **backup stage** is not configured, LandingLens on Snowflake has a mechanism to create application backup files. These can be used to help restore the LandingLens application, even if your organization hasn’t manually set up backup files.

### What Do the Application Backup Files Contain?

The application backup files contain data about the LandingLens application itself, which makes it easier to re-install the application if it is deleted.

The application backup files do NOT contain images, models, or labeling, training, and inference work.

### When Are the Application Backup Files Created?

The application backup files are created in the following scenarios:

* You have not set up the [backup settings](./back-up-and-restore-landinglens-on-snowflake#create-backups-of-landinglens). In this case, application backup files will be saved every 1 hour and 4 backups will be retained.
* You set up the backup recurrence and max number of backups but left the **Backup to stage** field blank. In this case, backup files are saved based on the schedule you set.

### Where Are the Application Backup Files Saved?

The application backup files are saved to this internal stage: `core.backups`.

### Manage and Restore the Application Backup Files

To check the list of application backup files and their timestamps in the default location, run the following command in the [Get Backup Timestamps and Access Backup Files](./back-up-and-restore-landinglens-on-snowflake#get-backup-timestamps-and-access-backup-files) procedure.

```plsql theme={null}
LIST @core.backups PATTERN = 'landinglens-backup-.*manifest.json';
```

To restore the application backup files from the default location, run the following command in the [Restore a Backup](./back-up-and-restore-landinglens-on-snowflake#restore-a-backup) procedure. Replace `<TIMESTAMP>` with the timestamp for the backup file you want to restore.

```plsql theme={null}
CALL core.restore_backup('@core.backups/landinglens-backup-<TIMESTAMP>')
```


# Cameras
Source: https://landinglens.docs.landing.ai/cameras



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

Choosing the right camera for a computer vision application is a critical decision that can significantly impact the performance and success of your project. This article delves into the essential factors to consider when selecting a camera, including resolution, shutter type, and more. Understanding these key aspects will help you make an informed decision and ensure optimal results for your specific needs.

## Keep the "Big Picture" in Mind

Choosing the right camera is just one part of setting up your image capture system. Make sure you also select the right [lens](./lenses) and [lighting](./lighting).

The guiding principle in developing your camera, lens, and lighting system is that it should lead to reliable and repeatable results. Good data in leads to good data out.

## Camera Resolution

It is important to select a camera that provides sufficient resolution to isolate defects or objects in the camera's field of view. Camera **resolution** is the number of pixels the camera sensor has, typically defined by its width (x-axis) and height (y-axis) in pixels.

To determine what camera resolution you need, follow the steps outlined below.

### 1. Identify the Size of the Smallest Defect

First, identify the size of the smallest object you need to detect. For example, let’s say you want to detect scratches on a sheet of metal. You measure the samples of scratched metal you have and determine that the smallest scratch is 1 mm.

### 2. Determine the Number of Pixels Needed to Cover the Smallest Feature

To detect an object accurately, you need a certain number of pixels to cover it. The best practice is to use 5-10 pixels across an object (given excellent visible contrast).

Let’s say you decide to use 10 pixels.

### 3. Calculate the Spatial Resolution

Now that you know the size of the smallest object and you’ve determined how many pixels should cover that object, calculate the spatial resolution. **Spatial resolution** is the real-world size that each pixel represents in the captured image.

The equation for spatial resolution is:

Using the numbers from our example, the equation is:

This means that in our example, each pixel represents 0.1 mm of the real-world object.

### 4. Determine the Required Camera Field of View (FOV)

A camera’s **field of view (FoV)** is the area it can capture in one image. You can also think of FOV as the total area you want to inspect. To return to our example of detecting scratches on metal sheets, determine the size of the area you want to be captured in each image.

Let’s say that you want the camera to capture an area that is 100 mm x 100 mm.

### 5. Calculate the Required Camera Resolution

You can now plug in all your data points to determine the required camera resolution for your application.

This is the equation to calculate the camera resolution:

To use the information from our example, the equation is:

Based on these calculations, you would select a camera with a resolution of at least 1000 pixels in the x-axis to ensure you can detect the smallest defects accurately across your entire field of view. Camera sensors are made in specific resolutions, and the closest specific resolution (going up) from 1000 pixels is 1024x768.

## Rolling Shutter vs. Global Shutter

A **camera shutter** controls how long the camera’s sensor is exposed to light to capture an image. A camera is available with a *global shutter* or a *rolling shutter*.

A **rolling shutter** exposes the image sensor to light sequentially, line by line. This means that the top and bottom of the frame are captured at slightly different times. If the object in the frame is moving—like a bottle on a conveyor belt—a rolling shutter can result in a “jello effect”, which is when vertical lines appear wavy. Therefore, rolling shutter cameras are recommended for fixed or static applications, because the image might otherwise be distorted. Rolling shutter cameras are also significantly less expensive than global shutter cameras.

A **global shutter** is a type of camera sensor technology that captures an entire image at once. The exposure time of a global shutter camera starts and ends at the same time, which means that each pixel in the image sensor is exposed to light simultaneously. Because the entire frame is captured at once, moving objects do not exhibit the “jello effect”, or any skew or distortion. Therefore, global shutters are recommended for high-speed moving applications.

## Color vs. Monochrome Sensors

A camera can have either a **color sensor**, which captures images in full color, or a **monochrome sensor**, which captures images in black and white. Each can offer specific advantages, and your use case should help determine whether you choose a camera with a color or monochrome sensor.

Following the image acquisition process, every pixel of the image provides a grey level value. The typical quantization is based on 256 grey levels (8 bit), 1024 levels (10 bit) or 4096 (12 bit). The image obtained is monochrome (black and white).

To display a color image, 3 coordinates are required: a red coordinate, a green coordinate and a blue coordinate. The value of each coordinate can be expressed in the same way as a monochrome image, with a range of 256, 1024 or 4096 levels per channel. This results in 3 times the amount of data required, which in turn results in a loss of image resolution and image performance when compared to a monochrome sensor.

### Use a Color Sensor if Color Information Is Important

If the application requires the computer vision system to differentiate between colors, then a color sensor may be the best choice.

### Color Sensors Are Slower

A color sensor pixel has 8 bits for the red channel, 8 bit for the green channel and 8 bit for the blue channel. Therefore 3 times the data to be processed compared to a monochrome sensor where each pixel has 8 bits resulting in a higher processing time and a slower frame rate.

### Monochrome Sensors Can Achieve Higher Resolutions

A monochrome sensor can typically achieve a higher effective resolution than a color sensor. This is because monochrome sensors do not have a Bayer filter or any other color filters that block light and reduce the amount of light each pixel can capture.

As a result, each pixel on a monochrome sensor can collect more light, which leads to higher resolution and better image quality, particularly in low-light conditions.

## Camera Parameters

When setting up a computer vision application, understanding and optimizing the following camera parameters is crucial for achieving the desired image quality and performance:

* [Exposure](./cameras#exposure)
* [Frame rate](./cameras#frame-rate)
* [Gain](./cameras#gain)
* [Triggering system](./cameras#triggering-system)

Properly balancing these factors can enhance the efficiency and accuracy of the application.

### Exposure

Exposure time is the amount of time in which the light is allowed to reach the sensor. The higher the value, the higher the quantity of light represented on the resulting image.

Increasing the exposure time is the easiest way to expose more light to the sensor, although it should be balanced against the presence of noise in the image. An exposure time that is too high may cause motion blur, overexposure, and reduced frame rate.

### Frame Rate

The frame rate is the frequency at which a complete image is captured by the sensor, expressed in frames per second (fps). Set the frame rate based on the application.

For example, if you have a production line that inspects 1,000 bottles per minute, this is how you calculate the minimum frame rate:### Gain

Gain is a way to increase the amount of signal collected by the image sensor. Increasing the gain will increase the image noise so that the overall signal to noise ratio remains unchanged.

### Triggering System

A triggering system ensures that the camera captures an image 1) when the object is in the field of view of the camera and 2) when the lighting is correct. Most industrial cameras provide triggering options. Typically, a triggering system works by receiving an input from a trigger sensor, which then activates the camera and any necessary lighting.

A triggering system is especially important when taking images of moving objects, like an item on a conveyor belt, because it ensures that the item is in the field of view of the camera and is correctly lit.

## Can I Use a Cell Phone Camera or Webcam?

As a reminder, the guiding principle in developing your camera, lens, and lighting system is that it should lead to *reliable* and *repeatable* results.

If your use case is detecting small scratches on semiconductor wafers, then you will most likely need an industrial camera and a well-designed lighting and triggering system to reliably and repeatedly detect these defects.

However, if your goal is to create a mobile app that people can upload photos to to detect what bird species they see while bird-watching, then training the model on images taken from cell phones makes sense.


# Classes Overview
Source: https://landinglens.docs.landing.ai/classes



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

**Classes** are categories of labels that let you define an object in an image. For example, let's say you are inspecting playing card images and want to detect each suit: Club, Diamond, Heart, and Spade. In this case, you can create a class for each suit.

Each project can have a maximum of 255 classes.

<img alt="Classes_1" />

Classes are color-coded. This is useful to quickly identify a class in an image if you have multiple classes.

<img alt="Classes_2" />


# Classic Flow
Source: https://landinglens.docs.landing.ai/classic-flow



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✖</span></td>
    </tr>
  </tbody>
</table>

In early 2023, we improved and updated a few backend technologies in LandingLens. At that point, we migrated most customers to the “new” version of LandingLens.

Due to requirements for specific use cases, some users stayed with the previous version. That older version is referred to as “Classic Flow” or “the Legacy version” of LandingLens.

We stopped offering Classic Flow on February 12, 2023. If you onboarded to LandingLens after that date, you are NOT using Classic Flow.

## How do I know if I'm on the Classic Flow version?

If the **Models tab has an icon of a box**, you are on Classic Flow.

For example, the version below has a box icon on the Models tab, so it’s on Classic Flow.

<img alt="classic_flow" />

## What features aren't available in Classic Flow?

Due to incompatibility issues, Classic Flow doesn’t support the following features:

* [Cloud Deployment](./cloud-deployment), the streamlined process for deploying Models
* The ability to [delete Classes](./delete-classes)
* [Visual Prompting](./visual-prompting)
* Compatibility with our developer tools, including the  [APIs](https://landing-ai.github.io/public-rest-api/fastapi/#/), [Python library](https://github.com/landing-ai/landingai-python), and [JavaScript library](https://github.com/landing-ai/landingai-js).

## LandingEdge and Docker Support for Classic Flow

The last version of [LandingEdge](/landingedge/landingedge-overview) and [Docker](/landingedge/docker-deploy) deployment that supported Classic Flow models was **v2.11.81**. Future versions no longer support Classic Flow models.

This change allows us to improve performance and features for these deployment solutions. If you are using Classic Flow models, ensure you are using LandingEdge or Docker deployment v2.11.81 or earlier.

### Update to LandingEdge v2.11.81

As of May 7, 2026, LandingEdge v2.11.81 is no longer available to download from LandingLens using the typical [LandingEdge download process](/landingedge/download-and-install-landingedge).

If this version is required, request this version by contacting [support@landing.ai](mailto:support@landing.ai).

### Update to Docker v2.11.81

To pull the image for Docker deployment v2.11.81, run this command:

```shell theme={null}
docker pull public.ecr.aws/landing-ai/deploy:2.11.81
```


# Classification
Source: https://landinglens.docs.landing.ai/classification



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span> (see exceptions below)</td>
    </tr>
  </tbody>
</table>

**Classification** is used to categorize (or classify) the contents of an image as a whole. This project type is useful for distinguishing one object from another or trying to identify global characteristics or patterns of an image. For example: blurry or clear, dark or light, and plaid or striped.

Images for this project type should typically be more consistent and localized as the whole image is used as input for training the model.

## Classification Upload Methods

When you upload images to a Classification project, you are prompted to choose one of these methods for uploading and labeling images:

* [Classified Images](#upload-classified-images): Organize images by class in separate folders *before* you upload them. When you upload folders, the images will automatically be classified based on the titles of your folders.
* [Unclassified Images](#upload-unclassified-images): Label the images *after* you upload them, just as you would for other projects.

<img alt="Upload Methods" />

### Upload Classified Images

<iframe title="YouTube video player" />

<Info>If you're using  and want to load and classify images from a Snowflake stage, go to [Load Images from Snowflake into LandingLens](./load-images-from-snowflake).</Info>

If you have images separated into different folders in your computer's directory according to their class, this method is for you. When you upload folders, the images will automatically be classified based on the titles of your folders.

For example, let’s say you want to distinguish apples from bananas. You can create these folders: **Apples** and **Bananas**.

<img alt="classified folders" />

When you upload these folders, the images from each folder will automatically be classified based on the titles of the folders. The Classified Images method is preferred because you can organize your images first and not have to worry about labeling these images after upload.

<img alt="Classified Images" />

<Info>Before you upload folders of images with the Classified method, ensure that the folder titles reflect the classes you want to create.</Info>

<Info>Before uploading images to LandingLens, ensure that you’ve selected the Classified Images option. Otherwise, images won’t be labeled during the upload process. For example, the drag-and-drop method will use the Unclassified method, not the Classified option.</Info>

To upload classified images:

1. Open the classification project you want to upload images to.
2. Perform one of the following actions:
   * If you do *not* have any images already uploaded to your project, click the **Drop to Upload** area.
     <img alt="Drop to Upload" />
   * If you already have images uploaded to your project, click the **Upload** icon.
     <img alt="Upload Icon" />
3. Click **Classified Images**. This step is important as it's the only way to upload classified images.
   <img alt="Classified Images" />
4. Upload your folders to the **Classified Images Upload** area. LandingLens displays a preview of the images and their respective classes.
5. Click **Upload**. LandingLens uploads the images and classifies them according to their folder titles.
   <img alt="Upload" />

### Upload Unclassified Images

If your images are *not *already separated into different folders in your computer’s directory, you can use the** Unclassified Images\*\* method. When you upload images this way, you’ll need to assign classes to images afterward.

This option is fine if you don’t have many images. However, if you have several images, try to organize them into folders and use the [Classified Images](./classification#upload-classified-images) option.

To upload unclassified images

1. Open the classification project you want to upload images to.
2. Perform one of the following actions:
   * If you do *not* have any images already uploaded to your project, drag and drop the images you want to upload to the **Drop to Upload** area. LandingLens automatically uploads the images to your project.
     <img alt="Drop to Upload" />
   * If you already have images uploaded to your project, click the **Upload** icon.
     <img alt="Upload Icon" />
3. Click **Unclassified Images**.
   <img alt="Unclassified Images" />
4. Upload the images to the **Unclassified Images Upload** area. LandingLens displays a preview of the images.
5. Click **Upload**.
   <img alt="Upload" />

## Add Labels to Images in Classification Projects

If you have already uploaded images using the [Unclassified](./classification#upload-unclassified-images) method, you will need to add labels to your images manually. There are two options for adding labels to images in classification projects:

* On the **Build** page, you can create or select a class from the **Select Class** drop-down menu for each image accordingly. (The video below has no sound.)Your browser does not support the audio element.
  <video />
* Click to open an image. Create or select a class from the **Select Class** drop-down menu for each image accordingly.Your browser does not support the audio element.
  <video />


# Cloud Deployment
Source: https://landinglens.docs.landing.ai/cloud-deployment



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span> (see exceptions below)</td>
    </tr>
  </tbody>
</table>

The quickest and easiest deployment method is **Cloud Deployment**. At a high level, Cloud Deployment is the deployment tool built directly into LandingLens. You can set up the deployment in seconds, upload images, and see the predictions right away in LandingLens.

Now let's take a closer look at the Cloud Deployment process. First, you create an **endpoint**, which is a virtual environment hosted within the LandingLens app. If using , the LandingLens app exists within your Snowflake environment, so the model will be hosted in Snowflake. The model you select for the deployment will run on the created endpoint. Next, you send images to the endpoint, and the model runs inference. The results then display in the LandingLens interface.

Use any of the following methods to send images to your model for inference:

* Send images using a script from our Python library
* Send images using a script from our JavaScript library (not available in )
* Send images using a [cURL command](./cloud-deployment#run-inference-using-curl-commands) (not available in )
* Send images from your phone using  (not available in )

The Python, JavaScript, and cURL scripts automatically populate on the Deployment page when a model is deployed. You just need to fill in your API Key and image file path.

<Info>The only deployment option for  is Cloud Deployment.</Info>

<Info>You can run inference up to 40 times per minute per endpoint. If you exceed that limit, the API returns a `429 Too Many Requests` response status code. We recommend implementing an error handling or retry function in your application. If you have questions about inference limits, please contact your LandingAI representative or [sales@landing.ai](mailto:sales@landing.ai).</Info>

## Deploy Models to Endpoints

You can set up multiple endpoints, which lets you run different models. After an endpoint is created, it can't be renamed or deleted. The model used for an endpoint also can't be changed.

To deploy a model to a cloud endpoint:

1. Open the project.
2. Click **Models**.
3. Click the **Deploy** or **+** button in the **Deployment** column for the model you want to deploy.
   <img alt="CloudDeployment_03_2024_1" />
4. Select an existing endpoint (if applicable) or click **New Endpoint** and name it.
5. Click **Deploy**.
   <img alt="CloudDeployment_03_2024_2" />
6. LandingLens deploys the model to the endpoint and opens the **Deploy** page. You can now use this endpoint to run inference.
   <img alt="CloudDeployment_03_2024_3" />

<Info>You can create endpoints on the Deploy page, but you can't deploy models to those endpoints on that page.</Info>

## Try This Model

After you set up an endpoint, you can test model performance by using the **Try this model** tool. Using **Try this model** is a good way to "spot-check" a model's performance.

When you click **Try this model**, you can upload a few images to see how the model performs on them. Ideally, you should upload images that aren't already in the dataset and that match your real-world use case. If the model performs well on the new images, you can continue the deployment process. If the model doesn't perform well on the images, try uploading and labeling more images in your project. Then run **Try this model** again.

The **Try this model** tool runs inference on each image, so using this tool costs 1 credit per image. (The credit cost is not applicable when using .)

To use **Try this model**:

1. Open a project.
2. Click **Deploy**.
3. Select the endpoint you want to use.
4. Click **Try this model**.
   <img alt="tryThisModel_1" />
5. Upload images.
6. LandingLens runs the model and shows you the results. Adjust the **Confidence Threshold** slider to see how the model performs with different thresholds. Typically, a lower confidence threshold means that you will see more predictions, while a higher confidence threshold means you will see fewer.
   <img alt="tryThisModel_2" />

## JSON Output

When you run inference on images, the prediction results display in a JSON format. Learn how to parse the JSON response in [JSON Prediction Responses](./json-responses).

## Run Inference Using cURL Commands

<Info>Sending images using a cURL command is not available in .</Info>

<Info>You can run inference up to 40 times per minute per endpoint. If you exceed that limit, the API returns a `429 Too Many Requests` response status code. We recommend implementing an error handling or retry function in your application. If you have questions about inference limits, please contact your LandingAI representative or [sales@landing.ai](mailto:sales@landing.ai).</Info>

After you create an endpoint, you can run inference by running a cURL command. The cURL command automatically populates on the Deployment page when a model is deployed. You just need to fill in your API Key and image file path before running the command.

To run inference using a cURL command

1. Open a project.
2. Click **Deploy**.
3. Select the endpoint you want to use.
4. You can access the cURL command in two places:
   * If you haven't run inference, locate the **API Inference** section at the bottom of the page. Click the **cURL Command** tab and click **Copy** to save the cURL command to your clipboard.
     <img alt="cURLcommand_1(1)" />
   * If you've already run inference, click the **Actions** icon (...) at the top of the page and select **View API Command**. Click the **cURL Command** tab and click **Copy** to save the cURL command to your clipboard.
     <img alt="cURLcommand_2" />
5. Paste the cURL command into an API platform (like Postman) or integrate it into a script.
6. Update `YOUR_APIKEY` with your API Key. To generate the key, go to [API Keys](./api-key).
7. Update `YOUR_IMAGE` with the image file names you want to run inference on. For example, after updating the parameters, your cURL command could look like this:
   ```bash theme={null}
   curl --location --request POST 'https://predict.app.landing.ai/inference/v1/predict?endpoint_id=ab1cde23-2863-49be-ae86-181198ba5b1b' \
        --header 'Content-Type: multipart/form-data' \
        --header 'apikey: land_sk_a1bCdFGzrqeh0I782EEfCZaK8BzQ6d1pNw5YcAZN4iSsuZxyb0' \
        --form 'file=@"manufacturing_qa_123.jpeg"'
   ```
8. Run the command.
9. In LandingLens, open the project to the **Deploy** page (if it's already open, refresh the page). The results [display](./historical-data) at the bottom of the page.

### Example: Run the cURL Command from Postman

<Info>The procedure in this section is based on the user interface of Postman at the time of this article’s publication. However, this interface may change over time. Refer to the [Postman documentation](https://learning.postman.com/) for the current information about how to use this application.</Info>

There are several ways to run the cURL command to run inferences. If you're not familiar with cURL commands, or you just want to test out the command, you can run the cURL command from Postman. Postman is a third-party application that, among other things, lets you run cURL commands for free. LandingAI isn't affiliated with Postman, and we recommend you do your own research to determine if this tool is right for you.

The following example is intended only to show you one of the ways to run the cURL command.

#### Prepare the cURL Command

1. Copy the cURL command from the LandingLens Deploy page and paste it into a text editor.
   <img alt="Postman_cURL_1" />
2. Update `YOUR_APIKEY` with your API Key. To generate the key, go to [API Keys](./api-key).
3. Keep the `YOUR_IMAGE` placeholder; you can upload images through Postman later.
   <img alt="Postman_cURL_2" />

#### Set Up Postman and Run the cURL Command

1. Sign up for a free version of Postman.
2. Set up the Postman web app and download Postman Agent. For more information, check out the [Postman installation instructions](https://learning.postman.com/docs/getting-started/installation/installation-and-updates/).
3. Create or open a workspace in Postman.
4. Click **Import** in the left side bar.
   <img alt="Postman_cURL_3" />
5. Paste the cURL command. Postman automatically fills out the workspace with the command.
   <img alt="Postman_cURL_4" />
6. Click **Body**.
7. Click **Select files** and upload an image you want to run inference on.
   <img alt="Postman_cURL_5" />
8. Click **Send**.
   <img alt="Postman_cURL_6" />
9. The response displays as [JSON](./json-responses) at the bottom of the page.
   <img alt="Postman_cURL_7" />
10. In LandingLens, open the project to the **Deploy** page (if it's already open, refresh the page). The results display at the bottom of the page.
    <img alt="Postman_cURL_8" />


# Resources
Source: https://landinglens.docs.landing.ai/community



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

If you need help with LandingLens or LandingEdge, you've come to the right place—the  Support Center! Here you will find detailed articles and insightful [video tutorials](./videos/invite-members-to-landinglens-video) about how to use LandingLens and LandingEdge.

Below are some additional resources to help you make the most of the tools from .

## LandingPad, the  Community

Looking for tips or insights about using LandingLens? Interested in learning more about specific use cases? Then join [LandingPad](https://community.landing.ai/), the community of  users! Here, you can:

* Ask for help or tips
* Check out the release notes
* See the product roadmap
* Give product feedback

## LandingLens Computer Vision Fundamentals Course

Check out the free [LandingLens Computer Vision Fundamentals Course](https://community.landing.ai/c/landinglens-fundamentals/) to learn about computer vision basics and how to apply those concepts to developing accurate computer vision models in LandingLens. Plus, users who complete the course earn a certificate and a community badge.

## APIs

Create, manage, and deploy computer vision models with our [REST APIs](https://landing-ai.github.io/public-rest-api/fastapi/#/operations/upload_image_v1_projects__project_id__images_post).

## Python and JavaScript Libraries

&#x20;offers [Python](https://github.com/landing-ai/landingai-python) and [JavaScript](https://github.com/landing-ai/landingai-js) libraries to enable you to programmatically manage your dataset and run inference. The libraries are available in [GitHub](https://github.com/landing-ai) and include example use cases and sample notebooks.

## Upcoming Events

&#x20;regularly hosts webinars, participates in conferences, and facilitates in-person learning events. To get the details on our upcoming activities, check out our [Events](https://landing.ai/events/) page.

## Give Feedback or Report Issues

You can submit feedback and notify us of bugs directly from LandingLens! Click the blue **Feedback** tab when you're in LandingLens and share your input with us.

<img alt="feedback_button" />

## Contact Us

Need to get a hold of ? Send us a message using our [contact form](https://landing.ai/contact-sales/).


# Compare Models
Source: https://landinglens.docs.landing.ai/compare-models



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

The Models page is a great way to get a high-level view of how different models performed on multiple datasets at once. However, if you'd like to see more details about how two specific models compare, use the **Compare Models** tool. The Compare Models tool is a great way to evaluate performance on multiple iterations of the model. It can help you identify if you need to improve your labels, datasets, and hyperparameters.

When you run the Compare Models tool, you set a **baseline** model and a **candidate** model. LandingLens then shows you if the candidate model performed better or worse across several metrics. You can even see a side-by-side comparison of how the baseline and candidate models performed on each image in the dataset.

<img alt="compareModels_overview_Jan_2025" />

<Info>Comparisons are generated on-demand, and are not saved.</Info>

## Run the Compare Models Tool

To compare two models:

1. Open the project to the **Models** tab.
2. Hover over the cell for one of the models you want to compare and click the **Compare** icon that appears. This model will be the *baseline* in the comparison. In other words, the second model will be compared as either better or worse than this model.
3. Click the cell for the second model you want to compare. This model will be the \*candidate \*in the comparison. In other words, this model will be compared as either better or worse than the first model.
   <Info>Want to switch the baseline and candidate models? Click the **Switch** icon.</Info>
4. Click **Compare**.
   <img alt="CompareModels_Jan_2025_01(2)" />
5. The Compare Models window opens and shows the difference in performance between the two models.
   <img alt="CompareModels_Jan_2025_02" />

## Model Performance Scores

The top of the Compare Models window shows how each model performed on the *evaluation set*. It also shows the difference in score between the two models. For example, in the image below, The F1 score for the candidate model is 2.8% higher than the F1 score for the baseline model (92.3 - 89.5 = 2.8).

These performance scores are included:

* F1 (for Object Detection, Classification, and Anomaly Detection)
* IoU (for Segmentation)
* Precision
* Recall

<img alt="compareModels_scores(1)" />

## Compare Training Settings

To see the model training information for each model, click **Compare Training Settings**.

<img alt="compareModels_settings_1" />

This opens a table with a side-by-side comparison of the settings used to train each models. Differences in training settings are highlighted.

<img alt="compareModels_settings_2" />

## Confusion Matrices

The Compare Models window includes a confusion matrix for both the baseline and candidate model so that you can quickly compare how they performed on each class in the evaluation set.

Each confusion matrix counts ground truth labels versus model predictions. The y-axis represents each ground truth label. The x-axis represents each possible model prediction.

Each cell shows the count of images that correspond to particular ground truth class-predicted class pair. For example, in the image below, the **baseline** model correctly predicted the class "Dolphin" 15 times and misclassified it 7 times, whereas the **candidate** model correctly predicted it 19 times and misclassified it 3 times.

<img alt="compareModels_confusionMatrix" />

<Info>For detailed information about confusion matrices and their correspoding Precision and Recall scores, go to [Performance Report](./performance-report).</Info>

## Compare All Images

Click **All Images** to see a visual comparison of all images. This shows three versions of each image in the evaluation dataset:

* **Ground truth**: The original image with the ground truth (labels) that you added.
* **Baseline model**: The predictions of the candidate model.
* **Candidate model**: The predictions of the candidate model. LandingLens highlights an image if the candidate model performed better or worse than the baseline for that specific image.

<img alt="compareModels_AllImages_1" />

Click a set of images to see more information about those images.

<img alt="compareModels_AllImages_2" />

### Compare All Images - Classification and Anomaly Detection

Because classes are assigned to an entire image in Classification and Anomaly Detection projects, it doesn't make sense to show the predictions as an overlay. Therefore, LandingLens shows the images and lists the ground truth and predictions next to the images.

<img alt="compareModels_AllImages_Class" />


# Create Classes
Source: https://landinglens.docs.landing.ai/create-classes



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

You can create a maximum of 255 classes for Classification, Object Detection, and Visual Prompting. However, there are no restrictions on the number of classes for Segmentation.

<Info>Classes can't be added, deleted, or changed in Anomaly Detection projects. The available classes are Normal and Abnormal.</Info>

## Create Classes

To create a class:

1. Open the project you want to add classes to.
2. Click the **Actions** button (ellipses) and select **Manage Classes**.
   <img alt="CreateClass_1" />
3. Click **Create Class**.
   <img alt="CreateClass_2" />
4. Classes are color-coded. This is useful to quickly identify a class in an image if you have multiple classes. Select a color for your class. (You can also click the **+** icon to select a custom color.)
5. Enter a brief, descriptive name for your class.
   <Info>Class names cannot be edited. If you want to rename an unused class, you must delete that class.<br />Classes cannot be named “Ok” (or any variation of its capitalization) in Object Detection and Segmentation Projects.</Info>
6. Click **Create**. Your class is created. You can now add descriptions and images to your class.
   <img alt="CreateClass_3" />


# Manage Projects
Source: https://landinglens.docs.landing.ai/create-projects



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

A **project** is like a folder—it will hold all the images, classes, labels, and metadata.

## Create a Project

To create a project:

1. If you haven't created any projects yet, click **Start First Project** on the main screen.

   <img alt="CreateProject_First_1(1)" />

   Or, if you've already created a project, click the **Create Project** tile.

   <img alt="CreateProject_1(3)" />
2. Click the **Edit** icon and enter a brief, descriptive name for your project in the **New Project** field. (You can also name the project later.)
   <img alt="CreateProject_2(1)" />
3. Select the [project type](./project-types).
   <img alt="CreateProject_3(1)" />
4. [Upload images](./upload-images) to your project.

You can also create a project directly within a folder. Navigate to the folder where you want to create the project, then follow the steps above. Projects created within folders appear on the **Home** tab and within their folder on the **Projects** tab.

## Organize Projects with Folders

Use folders to organize your projects within your organization. You can create nested folders to build a hierarchical structure that suits your workflow.

With folders, you can:

* Create nested folders to organize projects
* Move projects between folders
* Search within a specific folder or across all projects
* Navigate through folders using breadcrumb navigation

### Folder Permissions

All organization members can view folders, regardless of individual project permissions.

Folder management permissions depend on your [member role](./members):

* **Collaborators**: Can view folders and move their own projects into folders, but cannot create, move, rename, or delete folders.
* **Admins and Owners**: Can create, move, rename, and delete folders.

### Create a Folder

Admins and Owners create folders.

To create a folder:

1. Click **Projects** at the top of the page.
2. Click the **Create Folder** button.
3. Enter a name for the folder.
4. Click **Create**.

To create a subfolder inside an existing folder:

1. Navigate to the parent folder.
2. Click the **Create Folder** button.
3. Enter a name for the subfolder.
4. Click **Create**.

### Move Projects to Folders

Users can move projects they created or projects they are the Owner of.

To move a project to a folder:

1. Click **Projects** at the top of the page.
2. Locate the project you want to move.
3. Click the **Actions** icon (three dots) on the project card.
4. Select **Move to**.
5. Navigate to the destination folder or select the root level. You can also create a new folder during this process.
6. Click **Move**.

### Move Folders

Admins and Owners can move folders to different locations.

To move a folder:

1. Click **Projects** at the top of the page.
2. Locate the folder you want to move.
3. Click the **Actions** icon (three dots) on the folder card.
4. Select **Move to**.
5. Navigate to the destination folder or select the root level. You can also create a new folder during this process. (You cannot move a folder into itself or into one of its subfolders.)
6. Click **Move**.

### Rename a Folder

Admins and Owners can rename folders.

To rename a folder:

1. Click **Projects** at the top of the page.
2. Locate the folder you want to rename.
3. Click the **Actions** icon (three dots) on the folder card.
4. Select **Rename**.
5. Enter the new name.
6. Press **Enter** or click outside the text field to save.

### Delete a Folder

Admins and Owners can delete a folder if it is empty (contains no projects or subfolders).

To delete a folder:

1. Click **Projects** at the top of the page.
2. Locate the folder you want to delete.
3. Click the **Actions** icon (three dots) on the folder card.
4. Select **Delete**.
5. Confirm the deletion.

## View Projects

### View the Most Recently Opened Projects

To view the last three projects recently opened by anyone in your Organization, click the **logo** in the top left corner.

To see all projects, click  **View All** or **Projects**.

<img alt="ViewProjects_Home_2" />

### View All Projects

To view all projects in your Organization, click **Projects** at the top of the page.

<img alt="ViewProjects_All_2" />

### Navigate Through Folders

To view projects within a folder:

1. Click **Projects** at the top of the page.
2. Click on a folder to open it.
3. Use the breadcrumb navigation at the top to move back to parent folders or return to the root level.

## Search for Projects

Click **Projects** at the top of the page. Enter the project name, type, or creator in the search bar. To narrow down results, click the project type.

<img alt="Projects_search_type" />

When you search, a **Location** column displays in the results showing the full folder path where each project or folder is stored.

When you are inside a folder, search results are scoped to that folder and its subfolders by default. To search across all folders in your organization, select the **All folders** option.

To change how projects are sorted, click **Last Opened** and select a sort option.

<img alt="projects_sort" />


# Snowflake Credit Management
Source: https://landinglens.docs.landing.ai/credit-management



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✖</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

Snowflake [credits](https://docs.snowflake.com/en/user-guide/cost-understanding-compute) are used to pay for the consumption of resources on Snowflake. Like other apps and functions in Snowflake, running  consumes credits.

The  team has streamlined functionality to minimize credit consumption and is continuing to optimize  to use credits more efficiently.

To manage credit usage, use the [LandingLens Configs](./credit-management#access-the-cpu-and-gpu-settings-landinglens-configs) section in Snowsight to update the CPU and GPU resources used by LandingLens. You can also [suspend](./credit-management#suspend-the-app) the LandingLens app if needed.

<img alt="LLSF_configs_11_22_2024" />

## Access the CPU and GPU Settings (LandingLens Configs)

1. Open Snowsight.
2. Go to **Data Products** > **Apps** > **LandingLens Visual AI Platform**.
3. Click **Launch App**.
   <img alt="locate_inference_statement_1" />
4. Click **APP\_WIZARD**.
5. Click **Settings**.
6. Expand the **LandingLens Configs** section.
7. If needed, update the [Installation Size](./credit-management#set-the-installation-size-cpu-resources), [Number of GPUs](./credit-management#set-the-number-of-gpu-training-instances), and [Auto-Suspend GPU](./credit-management#autosuspend-gpu) settings.
8. Click **Save**.
   <img alt="LLSF_configs_11_22_2024" />
9. Click **Main**.
10. Click **Refresh Installation**. The installation must be refreshed for the changes to go into effect.
    <img alt="LLSF_refreshInstall_11_22_2024" />

## Set the Installation Size (CPU Resources)

In the [LandingLens Configs](./credit-management#access-the-cpu-and-gpu-settings-landinglens-configs), you can configure the **Installation Size** of the LandingLens app, which is the number of CPU machines and service replicas used by the app.

The sizes are all relative to the smallest size, which is the POC (the proof-of-concept) size.

Typically, using a smaller size leads to the consumption of fewer credits. We recommend increasing the size if you notice the app working slowly or if you have many users simultaneously using the app, running training, or running inference. If running LandingLens in production, consider using the Medium or Large size.

If you change this setting, you must refresh the installation for the changes to go into effect (click **Main** > **Refresh Installation**).

<img alt="LLSF_installSize" />

| Installation Size | Description                                                                                                                                 |
| ----------------- | ------------------------------------------------------------------------------------------------------------------------------------------- |
| POC               | This is the "proof of concept" setting, which is designed for users who want to learn how to use LandingLens and perform small-scale tests. |
| Small             | This is 2x the size of POC.                                                                                                                 |
| Medium            | This is 3x the size of POC, and is the default size when LandingLens is installed.                                                          |
| Large             | This is 4x the size of POC.                                                                                                                 |
| Xlarge            | This is 5x the size of POC.<br />                                                                                                           |

## Set the Number of GPU Training Instances

LandingLens uses GPUs during the model training process. By default, one GPU node is allocated for model training, but you can increase the number of GPU nodes in the [LandingLens Configs](./credit-management#access-the-cpu-and-gpu-settings-landinglens-configs). The maximum number of GPU nodes is five. Typically, increasing the number of GPU nodes increases the rate of credit consumption.

To change the number of allocated GPU nodes, update the **Number of GPU training instances** field. If more than one GPU node is allocated, [Auto-Suspend GPU](./credit-management#autosuspend-gpu) cannot be enabled.

If you change this setting, you must refresh the installation for the changes to go into effect (click **Main** > **Refresh Installation**).

<img alt="LLSF_numGPU" />

## Auto-Suspend GPU

You can configure the app's **Auto-Suspend GPU** setting to automatically suspend a GPU node after the period of inactivity that you specify. Typically, suspending a GPU node decreases credit consumption when you're not using the app.

Consider the following before configuring Auto-Suspend GPU:

* Auto-Suspend GPU is avaible only when one GPU node is allocated via the [Number of GPU training instances](./credit-management#set-the-number-of-gpu-training-instances) setting.
* Using Auto-Suspend GPU does not suspend any warehouses or compute pools.
* If the GPU node is suspended and you train a model, it will take about 6 minutes for the GPU node to re-activate.
* Turning on Auto-Suspend GPU when a GPU node is in use will not interrupt the service using it. GPU nodes will only auto-suspend after the GPU services are idle for the period of time you specify.

### Turn On Configure Auto-Suspend GPU

In the **GPU Services Will Suspend** field, enter the number of minutes of inactivity after which GPU services will automatically suspend. For example, if you enter **5**, GPU nodes will suspend after 5 minutes of inactivity.

To turn off Auto-Suspend GPU, enter **-1**. (This is the default setting.)

If you change this setting, you must refresh the installation for the changes to go into effect (click **Main** > **Refresh Installation**).

<img alt="LLSF_AutoSuspendGPU_11_22_2024" />

## Suspend LandingLens

You can run a SQL command to suspend the LandingLens app. Suspending the app suspends the underlying compute pools.

When the app is suspended, you can then run another SQL command to resume it. Resuming the app takes about 15 minutes.

Make sure that there are no active model training jobs or file syncs when you suspend an app. Otherwise, those processes will fail.

You can use [Snowflake tasks](https://docs.snowflake.com/en/sql-reference/sql/create-task) to schedule the suspend and resume tasks to run at specific times.

### Prerequisites

* You must be granted the [LLENS\_PUBLIC application role](./llens-public-application-role) to run this function.
* The inference function requires the name of your LandingLens instance (`APP_NAME`). To locate the name, go to [Name of LandingLens Instance](./app-name).

### Suspend the App

Run the following SQL command to suspend the app, where `APP_NAME` is the name of your LandingLens instance. To locate the name, go to [Name of LandingLens Instance](./app-name).

```bash theme={null}
CALL APP_NAME.core.suspend_services('APP_NAME');
```

### Resume the App

Run the following SQL command to resume the app, where `APP_NAME` is the name of your LandingLens instance. To locate the name, go to [Name of LandingLens Instance](./app-name).

```bash theme={null}
CALL APP_NAME.core.resume_services('APP_NAME');
```

## Check Compute Resources

To check the CPU and GPU resources used by the LandingLens app:

1. Open Snowsight.
2. Go to **Data Products** > **Apps** > **LandingLens Visual AI Platform**.
3. Click **Compute**. The CPU and GPU resources display (LANDINGLENS\_SNOWFLAKE\_CPU and LANDINGLENS\_SNOWFLAKE\_GPU).
   <img alt="LLSF_compute" />


# Curate High-Quality Datasets
Source: https://landinglens.docs.landing.ai/curate-high-quality-datasets



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

<iframe title="YouTube video player" />

It's important to consider the images you’re feeding your model. In this section, you’ll learn best practices and tips to consider when selecting images for your computer vision project.

## Use High-Quality Images and Dump the Rest

A model will only be as good as the dataset you train it on. Think of the phrase, "Garbage in, garbage out." If you feed your model low-quality images, you will likely receive poor performance. On the other hand, if you feed your model high-quality images, you will likely have great performance.

LandingLens is built on a data-centric approach. This means it’s better to have fewer high-quality images than many poor-quality ones.

### What Are High-Quality Images?

When we talk about high-quality images, we don’t just mean the resolution of the images. There are many factors when it comes to high-quality images, including:

* **Variability**: Your images should represent different real-life variations of the objects of interest.
* **Consistency**: The lighting, perspective, and background should be consistent.
* **Clarity**: Ensure your images are free from blurriness, noise (meaningless data), and similar artifacts.
* **Background**: Try to keep the background as uncluttered as possible so the model can focus better on the object of interest.
* **Resolution**: Images should have a sufficient resolution to capture intricate details. We recommend having at least 10 pixels across the smallest feature you want to detect.

### Variability: Real-World Scenarios Should Outweigh Other Factors

The most important factor to consider when curating a dataset is **variability**, which is that the images should represent different real-life variations of the objects of interest. It's important that the images in the dataset are similar to the images the model will see when it's used because this helps the model recognize patterns and features that will appear in real-world situations.

Depending on the use case, it might seem like variability is at odds with **consistency**. For example, if your goal is to detect motorcycles in *traffic cam footage*, then you should include images from different intersections, from different times of days, of different motorcycles, etc. But you might still be able to control consistency. For example, you could train on images only from traffic cams to mimic the real-world angle, perspective, and resolution that the model will encounter.

In other use cases, you might be able to control the variables for both the training dataset and the real-world use case. For example, if your goal is to detect scratches on a motorcycle on a *production line*, then you can control camera placement, lighting, the type of motorcycle, etc.

### Ask These Questions to Help Determine Quality

Take a moment to look at the images you want to train your models on. Then consider these questions:

* Are the images dark or well-lit?
* Are the images clear or blurry?
* Can you clearly identify the object of interest or region of interest, or do you need a magnifying glass?
* Are your images similar to what you’ll be running inference on when you deploy your model?
* Do your images represent all use cases relevant to the object of interest?

### Example: Identify High-Quality Images

Take a look at the set of images below. Which would you choose to keep? Which ones would you throw out and why?

<img alt="Hazelnut Dataset" />

If you chose to keep 1, 2, and 4, and throw out 3, 5, and 6, then you’re correct! Number 3 is too dark, number 5 is blurry, and number 6 is too bright.

<img alt="Answers" />

## How Many Images Do I Need?

If you ever had this question, you’re not alone. This is the question we get the most, and the answer is: it depends.

LandingLens requires that you have at least 10 labeled images before you can train a model. Are only 10 images enough to train with? This also depends on your use case.

The more image examples you provide to a model, the more it will “learn” the relevant features of the object of interest.

* If you have a simple use case, like detecting whether a bolt is present or missing on a component, 10 images might be enough.
* If you have a complex use case, like detecting the morphology of tissues and cells to determine whether they’re cancerous, you’ll likely need more than 10 images.

### Ask These Questions to Help Determine How Many Images You Need

When you’re selecting your images for your project, consider these questions:

* How elaborate is the object of interest?
* How many types of objects of interest are there?
* Are there many variants of the object of interest?
* Do the objects of interest in your images represent real-life use cases?
* Do your images represent a balanced number of classes?

### Balance the Number of Images for Each Object of Interest

When you want a model to detect a certain object of interest, you create a *class* for that object. A *class* is basically a name for an object you want to detect. For example, if you want a model to detect apples and bananas, create an Apple class and a Banana class.

If your project has multiple classes, upload about the same number of images per class. Having a balanced number of images per class helps the model accurately detect objects for each class. So if you're detecting Apples and Bananas, 50% of the images should be apples, and 50% of the images should be bananas.

### Tips for Object Detection Projects

Models in Object Detection projects learn based on the contents of the bounding boxes (the areas you identify as the Ground Truth). Therefore, it's important to get a well-represented spread of bounding boxes for each class.

For complex projects (like circuit boards), we recommend you include a minimum of 50 bounding boxes per class. If one image has five bounding boxes, then this counts as five, not one.

### Tips for Classification Projects

Each image can only have one class applied to it. Therefore, if an image meets the criteria for more than one class, we recommend that you don't include it in training because it could confuse the model.

For complex projects (like circuit boards), we recommend you include a minimum of 50 images per class.

### Tips for Segmentation Projects

Models in Segmentation projects learn based on the specific pixels marked by the lines or shapes you add to the images (the areas you identify as the Ground Truth).

Therefore, it's important to get a well-represented spread of marked areas for each class.

Typically, a Segmentation project requires fewer images than an Object Detection project. This is because a Segmentation project allows you to label areas more precisely.

For complex projects (like circuit boards), we recommend you include about 20 to 30 labeled areas per class. If one image has five labeled areas, then this counts as five, not one.

### Tips for  Projects

You only need to label a few small areas of images to train a  model. For more information, go to [Visual Prompting](./visual-prompting).


# Custom Training
Source: https://landinglens.docs.landing.ai/custom-training



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span> (see exceptions below)</td>
    </tr>
  </tbody>
</table>

In many cases, [Fast Train](./train-models) is the optimal method for creating a model. However, some advanced use cases require granular control over pre-processing and hyperparameter tuning. In these situations, you can use the Custom Training method (also called "Advanced Training") to create models. With Custom Training, you can control how the image is sized and cropped before model training, what augmentations are applied during training, and how many epochs (cycles) the training goes through.

The Custom Training process is designed for users who are familiar with machine learning concepts and understand how the different settings impact the resulting model. If you don't have a background in machine learning, we recommend using the [Fast Train](./train-models) method instead.

## Run Custom Training

1. Open the project you want to train.
2. Click the downward-facing arrow next to **Train** and select **Custom Training**.
   <img alt="custom_train_2024_1(1)" />
3. Select a dataset from the drop-down menu. You can select from the dataset currently on the Build page (the **current version**) or an existing [dataset snapshot](./dataset-snapshots). If you select the **current version**, LandingLens creates a dataset snapshot of that data.
   <img alt="custom_train_2024_2_SetUpYourData" />
4. If you selected the **current version** dataset and some labeled images don't have splits assigned, assign splits. Otherwise, the splits display and cannot be changed. For detailed information, go to [Split Setup](./custom-training#split-setup).
5. Click **Next**.
   <img alt="custom_train_2024_3_Splits" />
6. Configure the [hyperparameters](./custom-training#hyperparameters), [transforms](./custom-training#transforms), and [augmentations](./custom-training#augmentations). When processing images, LandingLens applies changes in the following order: rescale/resize, crop, augmentations.
   1. To edit a setting, hover over the value and click the **Edit** icon that appears.
   2. To add a setting, click the **Add** icon.
   3. To see how the settings impact the images, click the **Preview** icon. For more information, go to [Preview Transforms and Augmentations](./custom-training#preview-transforms-and-augmentations).
      <img alt="custom_train_2024_4(1)" />
7. Review the credits that your organization will be charged for the training process and future predictions (inferences). You might need to scroll to the right to see the credit calculations. For more information, go [here](./custom-training#credit-calculation-for-custom-training). (The credit cost is not applicable when using .)
   <img alt="custom_train_2024_5" />
8. After configuring the settings, click **Train**.
   <img alt="custom_train_2024_6(1)" />
9. LandingLens runs the [Model Training process](./train-models#model-training-process) and creates a model. Once training completes, you can view and compare the model's performance on the [Models page](./compare-models).

### Add or Duplicate Models

<iframe title="YouTube video player" />

Custom Training allows you to create multiple models for a dataset at once, each using different training settings. The selected dataset and splits remain the same. This is useful if you want to see how a certain setting impacts model performance.

There are two ways to do this:

* Click **Add Another Model**. This adds a row with the default settings.
* Hover over a row and click **Duplicate**. This adds a row with the same settings as that row.

<img alt="custom_train_addmodel_nocredits" />

## Split Setup

The second step of Custom Training is setting up or reviewing splits. The options depend on which dataset you selected, and if images have splits already:

* [If You Selected the Current Version of the Dataset and Images Don't Have Splits Yet](./custom-training#if-you-selected-the-current-version-of-the-dataset-and-images-dont-have-splits-yet)
* [If You Selected a Snapshot or Images Already Have Splits](./custom-training#if-you-selected-a-snapshot-or-images-already-have-splits)

### If You Selected the Current Version of the Dataset and Images Don't Have Splits Yet

If you selected the **current version** of the dataset, you can assign splits to labeled images that don't have splits assigned to them yet. If some labeled images in the dataset already have splits, you can only assign splits to the remaining images that don't have splits.

By default, the **Assign Split** setting is toggled on. This setting automatically assigns labeled images in each class into splits based on these percentages:

* **Train**: 70%
* **Dev**: 20%
* **Test**: 10%

In situations in which the resulting number of images isn't a whole number, the algorithm rounds up or down to the nearest whole number of images. For example, if Class A has 11 images, 70% of that is 7.70 images. Multiple splits can't be applied to an image, so the algorithm would add 8 images to the Train split.

The **Preview** section shows how the images are assigned. You can view the splits **By Class** or **By Split**.

<img alt="custom_train_splits_assign" />

### If You Selected a Snapshot or Images Already Have Splits

If you selected a snapshot *or* you selected the **current version** of the dataset and images in that dataset already have splits applied to them, LandingLens uses the assigned splits. Split assignment is part of a dataset snapshot, and data in a snapshot can't be changed.

In these situations, you can preview your splits (if you're using the **current version** of the dataset, you can return to the **Build** page and change split assignment there). You can view the splits **By Class** or **By Split**.

<img alt="custom_train_splits_preassigned" />

## Hyperparameters

A **hyperparameter** is a setting used to control the speed and quality of the learning process. Hyperparameters include these settings:

* [Epoch](./custom-training#epoch)
* [Model Size](./custom-training#model-size)

<img alt="custom_train_hyperparameters_2024" />

### Epoch

When your model trains, it works through your dataset multiple times. The completion of one cycle is called an *epoch*. Enter the number of cycles you want the model to perform in the **Epoch** field.

### Model Size

The Model Size refers to the architecture and number of parameters used to train the model. The options depend on your project type, but each has a trade-off between speed and performance.

#### Object Detection

* **RtmDet-\[9M]**: This option leads to the fastest training and inference times. Uses the [RTMDet](https://arxiv.org/abs/2212.07784) architecture and 9 million parameters.
* **RepPoints-\[20M]**: Train and run inferences faster than with **RepPoints-\[37M]**. Uses the [RepPoints](https://arxiv.org/abs/1904.11490) architecture and 20 million parameters.
* **RepPoints-\[37M]**: Capture more complex patterns in the training data. Training and running inferences will take longer. Uses the [RepPoints](https://arxiv.org/abs/1904.11490) architecture and 37 million parameters.
* **ODEmbedded-\[23M]**: Only use this architecture when deploying to embedded devices. For detailed information, go to [Embed-Optimized Models](./edge-ai).

#### Segmentation

* **FastViT-\[14M]**: Train and run inferences faster. Uses the [FastViT](https://arxiv.org/abs/2303.14189) transformer architecture and 14 million parameters.
* **SegFormer-\[14M]**: Capture more complex patterns in the training data. Training and running inferences will take longer. Uses the [SegFormer](https://arxiv.org/abs/2105.15203) semantic segmentation framework and 14 million parameters.

#### Classification

* **ConvNeXt-\[16M]**: Train and run inferences faster. Uses the [ConvNeXt](https://arxiv.org/abs/2201.03545) architecture and 16 million parameters.
* **ConvNeXt-\[29M]**: Capture more complex patterns in the training data. Training and running inferences will take longer. Uses the [ConvNeXt](https://arxiv.org/abs/2201.03545) architecture and 29 million parameters.
* **ConvNextEmbedded-\[16M]**: Only use this architecture when deploying to embedded devices. For detailed information, go to [Embed-Optimized Models](./edge-ai).

#### Anomaly Detection

* **RD4AD-\[160M]**: Uses a reverse distillation (RD) paradigm and 160M parameters.

## Transforms

A **transform** setting allows you to rescale, resize, and crop all the images in your dataset *before* model training starts. This is an important feature because all training images need to be a standard input size for your model. When processing images, LandingLens applies changes in the following order: rescale/resize, crop, augmentations.

Any transforms applied here are also applied to images you run inference on.

Make sure that the objects or regions you are trying to detect are clearly visible *after* applying these transforms. For example, if you crop images, make sure that the objects of interest are not cropped out.

You must apply either a **Resize** or a **Rescale with Padding**, but not both.

<img alt="custom_train_2024_transforms(1)" />

### Rescale Images (Maintain the Aspect Ratio)

The **Rescale with Padding** setting scales the images to the **Height** and **Width** you enter, while maintaining the original aspect ratio. If the dimensions entered don't match the aspect ratio, LandingLens adds padding—rows or columns of pixels—to either the top and bottom or sides to maintain the aspect ratio.

If you enter dimensions that maintain the original aspect ratio, LandingLens doesn't add any padding.

For example, let’s say the original size of an image is 1200x800, which is a 4:3 aspect ratio. You then rescale it to 512x512, which is a 1:1 aspect ratio. To maintain the 4:3 aspect ratio, LandingLens scales down the actual image to 512x341, and then adds padding to the top and bottom.

By default, the color of the padding is black. You can change it to be black, white, or a shade of gray. To do this, enter the grayscale value for the color of the padding in the **Padding Value** field. The range is 0 (black) to 255 (white).

<img alt="rescalewithpadding" />

### Resize Images

The **Manual Resize** setting resizes your images to the **Height** and **Width** you enter, and does *not* maintain the original aspect ratio. For example, if the entered dimensions don't match the original aspect ratio, the image will be squeezed or stretched.

For example, the screenshot below shows an image that was originally 1200x800 (a 4:3 aspect ratio) that was resized to 512x512 (a 1:1 aspect ratio). The image is stretched vertically to "fill in" the extra space at the top and bottom.

<img alt="manualresize" />

<Info>If you want to preserve the original aspect ratio, rescale your images instead.</Info>

### Maximum Size for Rescaling and Resizing

There is a maximum size for rescaling and resizing images. The specific size depends on the project type. The maximum is based on the total area, not a specific height or width. Example dimensions are provided in the following table as guidelines.

| Project Type     | Maximum Area | Example Maximum Dimensions |
| ---------------- | ------------ | -------------------------- |
| Object Detection | 2,250,000px  | 1500x1500px                |
| Classification   | 2,250,000px  | 1500x1500px                |
| Segmentation     | 1,048,576px  | 1024x1024px                |

For example, let's say you want to resize images in an Object Detection project:

* A resize of 1000x600px will work because the area is 600,000px, which is smaller than 2,250,000px.
* A resize of 1500x1501px will *not* work because the area is 2,251,500px, which is bigger than 2,250,000px.

<Info>Images in some projects can be larger, but there are trade-offs. For more information, go to [Large Image Support](#large-image-support).</Info>
<Info>If you rescale an image, the padding is included in the calculation of the image area.</Info>

#### Large Image Support

You can resize your images in Object Detection and Segmentation projects to be up to 36MP.

If you resize images to be larger than the following *total area*, the images are considered to be "large images":

* **Object Detection**: Over 2,250,000px (for example, anything larger than 1500x1500px)
* **Segmentation**: Over 1,048,576px (for example, anything larger than 1024x1024px)

Using "large images" in a computer vision model has these tradeoffs:

* These models can only be deploying using [LandingEdge](./landingedge/landingedge-overview) and [Docker](./landingedge/docker-deploy). [Cloud Deployment](./cloud-deployment) doesn't support models that were created with large images.
* The [Try Model](./model-settings#try-model) tool isn't compatible with these models.

### Crop Images

The **Crop** setting allows you to apply the same crop to all images. If you add a **Crop**, you must either rescale or resize the image first. This prevents the crop from falling outside the boundaries of images.

There are a few ways to select the locations and dimensions of the cropped area:

* Enter the points of each corner of the cropped area in the **X min**, **Y min**, **X max**, and **Y max** fields.
* Click and drag the handles of the crop box.
* Click inside the crop box and drag it.

<img alt="crop_2024" />

## Augmentations

The **Augmentation** settings apply changes to your images—like increasing brightness and adding blurs—before the model trains on the images. This increases the variations of your images, which allows the model to "prepare" for more situations, like changes in lighting. Augmentations are applied after resizes/rescales and crops.

When you set up an augmentation you choose the probability that the augmentation will be applied during training. The augmentations are applied at each epoch, which prevents overfitting. For example, if you add the Random Brightness augmentation with a probability of 50%, then half of the images might be brightened during the first epoch, another half during the second epoch, and so on.

By setting up automated augmentations in LandingLens, you get the benefits of a greater variety of images without having to take those images or edit them.

LandingLens offers these augmentations for Custom Training:

* [Random Brightness](./custom-training#random-brightness)
* [Blur, Motion Blur, Gaussian Blur](./custom-training#blur-motion-blur-gaussian-blur)
* [Hue Saturation Value](./custom-training#hue-saturation-value)
* [Random Contrast](./custom-training#random-contrast)
* [Horizontal Flip](./custom-training#horizontal-flip)
* [Vertical Flip](./custom-training#vertical-flip)
* [Random Augment](./custom-training#random-augment)
* [Random Rotate](./custom-training#random-rotate)

### Random Brightness

Apply **Random Brightness** for a chance that the images in your dataset will randomly brighten.

The Random Brightness setting is helpful if the lighting conditions might change. For example, if you take images at night, the objects you want to detect might be dark. If it's possible that sometimes you will run inference on images taken during the day, then the Random Brightness setting can show your model what the images might look like during the day.

If the lighting conditions will be consistent, then the Random Brightness setting might not be relevant. For example, if you're taking images in a cleanroom with no windows, you might not need Random Brightness.

The image and table below describe the settings for Random Brightness.

<img alt="RandomBrightness" />

| # | Setting                 | Description                                                                            |
| - | ----------------------- | -------------------------------------------------------------------------------------- |
| 1 | Random Brightness Range | The range of brightness values that can be applied to an image. The range is -1 to 1.  |
| 2 | Probability             | The likelihood that brightness will be applied to an image. The range is 0 to 1.       |
| 3 | Random Brightness       | Preview how images will look in the selected value.                                    |
| 4 | Set as Lower Limit      | Set the lower limit of the range (#1) to the value selected in Random Brightness (#3). |
| 5 | Set as Upper Limit      | Set the upper limit of the range (#1) to the value selected in Random Brightness (#3). |

### Blur, Motion Blur, Gaussian Blur

Apply one of the blur modifications for a chance that the images in your dataset will randomly blur. LandingLens offers these types of blurs:

* **Blur**: Makes the entire image look out of focus. This is a heavy blur.
  <img alt="blur_compare" />
* **Motion Blur**: Makes the entire image look like it's in motion.
  <img alt="motion_blur_compare" />
* **Gaussian Blur**: Makes the entire image look out of focus. This is a natural blur.
  <img alt="gaussian_blur_compare" />

The image and table below describe the settings for Blur, Motion Blur, and Gaussian Blur.

<img alt="blur_2024" />

| # | Setting                                                    | Description                                                                                             |
| - | ---------------------------------------------------------- | ------------------------------------------------------------------------------------------------------- |
| 1 | Blur Range<br />Motion Blur Range<br />Gaussian Blur Range | The range of blur values that can be applied to an image. The range is 3 to 100.                        |
| 2 | Probability                                                | The likelihood that blur will be applied to an image. The range is 0 to 1.                              |
| 3 | Blur<br />Motion Blur<br />Gaussian Blur                   | Preview how images will look in the selected value.                                                     |
| 4 | Set as Lower Limit                                         | Set the lower limit of the range (#1) to the value selected in Blur / Motion Blur / Gaussian Blur (#3). |
| 5 | Set as Upper Limit                                         | Set the upper limit of the range (#1) to the value selected in Blur / Motion Blur / Gaussian Blur (#3). |

### Hue Saturation Value

Apply **Hue Saturation Value** for a chance that the color intensity of the images will randomly change. Saturation is how "pure" the hue is. A saturation of 0 is black and white.

For example, some objects can be different colors, like a fish. You may want to change the hue (color of the image), so the model trains on fish with different colors.

The image and table below describe the settings for Hue Saturation Value.

<img alt="HueSaturationValue" />

| # | Setting                                                   | Description                                                                                                              |
| - | --------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------ |
| 1 | Hue Shift Range<br />Sat Shift Range<br />Val Shift Range | The range of hue, saturation, and value shift values that can be applied to an image. The range for each is -255 to 255. |
| 2 | Probability                                               | The likelihood that the hue, saturation, and value shift values will be applied to an image. The range is 0 to 1.        |
| 3 | Hue Shift<br />Saturation Shift<br />Value Shift          | Preview how images will look in the selected values.                                                                     |
| 4 | Set as Lower Limit                                        | Set the lower limit of the respective range (#1) to the value selected in the slider next to this (#3).                  |
| 5 | Set as Upper Limit                                        | Set the upper limit of the respective range (#1) to the value selected in the slider next to this (#3).                  |

### Random Contrast

Apply **Random Contrast** for a chance that the tone of the images will randomly change. Random Contrast helps simulate different camera settings or environments that a model might encounter.

* A low-contrast image looks washed out or slightly dimmed.
* A high-contrast image looks somewhat overexposed, and the colors merge into each other.

The image and table below describe the settings for Random Contrast.

<img alt="RandomContrast_2024" />

| # | Setting               | Description                                                                               |
| - | --------------------- | ----------------------------------------------------------------------------------------- |
| 1 | Random Contrast Range | The range of contrast values that can be applied to an image. The range is -1 to 1.       |
| 2 | Probability           | The likelihood that the contrast values will be applied to an image. The range is 0 to 1. |
| 3 | Random Contrast       | Preview how images will look in the selected value.                                       |
| 4 | Set as Lower Limit    | Set the lower limit of the range (#1) to the value selected in Random Contrast (#3).      |
| 5 | Set as Upper Limit    | Set the upper limit of the range (#1) to the value selected in Random Contrast (#3).      |

### Horizontal Flip

Apply **Horizontal Flip** for a chance that the image will randomly be mirrored (flipped) horizontally.

The Horizontal Flip augmentation has only one setting: **Probability**. Probability is the likelihood that the image will randomly be flipped horizontally. The range is 0 to 1.

<img alt="HorizontalFlip" />

### Vertical Flip

Apply **Vertical Flip**  for a chance that the image will randomly be mirrored (flipped) vertically.

The Vertical Flip augmentation has only one setting: **Probability**. Probability is the likelihood that the image will randomly be flipped vertically. The range is 0 to 1.

<img alt="VerticalFlip" />

### Random Augment

Select **Random Augment** to randomly apply a set of augmentations to your dataset. The table below describes the possible augmentations.

| Augmentation      | Description                                                                                                                                                                                                                                             |
| ----------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Identity          | Applies no changes to the image. By adding some images to the dataset that still look like the original image, the Identity method decreases the chances of the model training only on augmented images, and prevents overfitting.                      |
| Equalize          | Equalizes the image histogram, which increases contrast. This method is also referred to as *histogram equalization*.                                                                                                                                   |
| Rotate            | Rotates the image clockwise or counterclockwise by a random number of degrees. This can change the position of the image within its frame.                                                                                                              |
| Posterize         | Reduces the number of bits for each color channel. This method is also referred to as *posterization*.                                                                                                                                                  |
| Random Contrast   | Increases or decreases the contrast of the image.                                                                                                                                                                                                       |
| Random Brightness | Increases or decreases the brightness of the image.                                                                                                                                                                                                     |
| ShearX            | Shifts the pixels along the X-axis, so that the image looks slanted and stretched horizontally. This can change the position of the image within its frame. This method is also referred to as *shear mapping*, *shear transformation*, and *shearing*. |
| ShearY            | Shifts the pixels along the Y-axis, so that the image looks slanted and stretched vertically. This can change the position of the image within its frame. This method is also referred to as *shear mapping*, *shear transformation*, and *shearing*.   |
| TranslateX        | Moves the pixels horizontally by the same distance. This can change the position of the image within its frame. This method is also referred to as *translation*.                                                                                       |
| TranslateY        | Moves the pixels vertically by the same distance. This can change the position of the image within its frame. This method is also referred to as *translation*.                                                                                         |

#### Random Augment Settings

The image and table below describe the settings for Random Augment.

<img alt="RandomAugment_2024" />

| # | Setting           | Description                                                                                                                                                     |
| - | ----------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| 1 | Number Transforms | The number of augmentations you want to be applied to images. LandingLens will randomly apply this number of augmentations to the images. The range is 1 to 10. |
| 2 | Probability       | The likelihood that a random augmentation will be applied to an image. The range is 0 to 1.                                                                     |
| 3 | Magnitude         | How strong the applied augmentation will be. The range is 1 (weakest) to 10 (strongest).                                                                        |

### Random Rotate

Apply **Random Rotate** for a chance that images will randomly rotate.

The image and table below describe the settings for Random Rotate.

<img alt="RandomRotate_2024" />

| # | Setting             | Description                                                                                                                                                                               |
| - | ------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| 1 | Random Rotate Range | The range (in degrees) that images can be rotated by. The range is -180° to 180°.                                                                                                         |
| 2 | Interpolation       | Use this setting to resize images. The options are:<ul><li>Linear</li><li>Area</li><li>Cubic</li><li>Nearest</li><li>Lanczos4</li></ul>                                                   |
| 3 | Border Mode         | Use this setting to create a border around the image, like a photo frame. The options are:<ul><li>Constant</li><li>Replicate</li><li>Reflect</li><li>Wrap</li><li>Reflect\_101 </li></ul> |
| 4 | Probability         | The likelihood that the image will be rotated. The range is 0 to 1.                                                                                                                       |
| 5 | Random Rotate       | Preview how images will look in the selected value.                                                                                                                                       |
| 6 | Set as Lower Limit  | Set the lower limit of the range (#1) to the value selected in Random Rotate (#5).                                                                                                        |
| 7 | Set as Upper Limit  | Set the upper limit of the range (#1) to the value selected in Random Rotate (#5).                                                                                                        |

### Preview Transforms and Augmentations

Click the **Preview** icon in the Transforms and Augmentations columns to see how the effects can impact the images.

<img alt="CustTrainpreview_1" />

Because most Augmentations have a chance of not being applied, or of having a range of intensities, you can click **Re-Apply** to see more possible variations. For example, the Random Brightness augmentation could have a range of -1 to 1, and a Probability of being applied of 0 to 1. If you multiply the ranges (20 x 11), there are 220 possible outcomes for each image.

<img alt="CustTrainpreview_2" />

## Credit Calculation for Custom Training

<Info>The credit cost is not applicable when using .</Info>
The credit cost for Custom Training is based on the project type and custom training settings selected. In general, increasing any of the settings (like increasing the epoch) increases the cost to train and run inference.

With Custom Training, the cost to train the model and run inference on that model might be more or less than 1 credit.

After you configure your settings—and before you train the model—LandingLens shows you the exact credit cost it will take to train the model and run inference on it.

<img alt="custom_train_2024_5(1)" />

### Each Model Can Have a Different Inference Cost

If you run Custom Training multiple times in the same project, each resulting model can have a different cost for running inference. This is because each round of Custom Training can have multiple different settings, each of which impact the cost.

For example, you could have three models with the following inference costs in the same project:

| Model   | Training Type                           | Credit Cost for Inference |
| ------- | --------------------------------------- | ------------------------- |
| Model A | Fast Training (default training method) | 1 credit / image          |
| Model B | Custom Training                         | 1.62 credits / image      |
| Model C | Custom Training                         | 0.35 credits / image      |

## Custom Training FAQ

### Is Advanced Training the same thing as Custom Training?

Yes.

### When should I use Custom Training?

If the performance results of your model are unsatisfactory after a Fasting Train, switch to Custom Training.

<Info>Custom Training is intended for users who are knowledgeable in machine learning.</Info>

### I'm unfamiliar with machine learning. Can I use Custom Training?

We recommend using Fast Training so that LandingLens can fine-tune your model settings for you.

### What are your thoughts on "hyperparameter sweeps"?

After you create a model with Custom Training, you can fine-tune the Custom Training settings based on data and model performance. We do not recommend repeatedly training models with all possible settings (known as "hyperparameter sweeps") because that approach can quickly burn through your [credits](./plans#credits).


# Dataset Snapshots
Source: https://landinglens.docs.landing.ai/dataset-snapshots



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

You can create a "snapshot" of all or some images in your project's dataset at any time. A snapshot includes the selected images and their labels, splits, metadata, tags, and labeling tasks.

Data can't be added to a snapshot after it's created; you can think of it as "frozen". Keeping the data consistent allows you to accurately compare how different models perform on the same dataset.

With snapshots, you can:

* [Train a model](./dataset-snapshots#create-a-custom-trained-model-with-a-snapshot) based on the data in the snapshot.
* Create [new projects](./dataset-snapshots#create-new-projects-from-a-snapshot) from snapshots.
* [Revert your project](./dataset-snapshots#revert-to-a-snapshot) to a snapshot.
* [Download the dataset](./dataset-snapshots#download-the-dataset) and [class map](./dataset-snapshots#download-class-map) for a snapshot. This gives you the ability to re-upload the labeled images to LandingLens in the future, if needed.
* [Download a CSV](./dataset-snapshots#download-csv) with information about the images and labels in that snapshot.
* [Export a snapshot with the API](./dataset-snapshots#export-a-snapshot-with-the-api) instead of downloading it from the app.

## Create Snapshots

There are two ways that snapshots are created:

* Manually [create a snapshot](./dataset-snapshots#manually-create-snapshots), which saves the information currently in your project.
* Train a model. LandingLens automatically saves a snapshot of your dataset when you [train a model](./train-models).

### Manually Create Snapshots

To save a snapshot:

1. Select the images you want to include:
   * To save all images in your dataset as a snapshot, click the **Snapshot** icon and select **Save snapshot**.
     <img alt="SaveSnapshotAll" />
   * To save only some images in your dataset as a snapshot, select the images you want, click **Options**, and select **Save Snapshot**.
     <img alt="SaveSnapshotSelect" />
2. LandingLens automatically names the snapshot with the current timestamp. If you’d like to change it, enter a custom name in the **Snapshot Name** field.
3. (Optional) Enter a short description of the snapshot in the **Description** field.
4. (Optional) If you want to review the splits and labeling status of the images, expand the section at the bottom.
5. Click **Save snapshot**.
   <img alt="SaveSnapshotPopup" />

## View Snapshots in the Snapshot Dashboard

To view all the snapshots for a project, click the **Snapshot** icon and select **Show snapshot list**.

<img alt="ShowSnapshotList" />

This Snapshot dashboard allows you to review all of your snapshots and drill into each one. Here are the main sections of the Snapshot dashboard:

* [Snapshots Panel](./dataset-snapshots#snapshots-panel)
* [Images tab](./dataset-snapshots#images-tab)
* [Snapshot Summary tab](./dataset-snapshots#snapshot-summary-tab)

<img alt="SnapshotDashboard" />

### Snapshots Panel

Click the snapshot you want to view in the Snapshots panel. Snapshots are listed in the chronological order they were created.

By default, the **Hide auto-generated snapshots** checkbox is selected. This hides the snapshots that LandingLens automatically created when you trained models.

<img alt="SnapshotsPanel" />

### Images Tab

Open the **Images** tab to see the thumbnails for the images in the dataset. You can filter, sort, and change the sizes of the thumbnails, just as you can in the Build view.

<img alt="ImagesTab" />

### Snapshot Summary Tab

Open the **Snapshot Summary** tab to see the number of images and classes in the snapshot, the label statuses, the split distribution, the snapshot description, the class distribution, and what models were trained using the data in the snapshot.

<img alt="SnapshotSummaryTab" />

## Create a Custom Trained Model with a Snapshot

<Info>The default training method (also known as [Fast Training](./train-models)) is not available for snapshots.</Info>
You can train a model based on the data in a snapshot. This allows you to generate multiple models on different datasets in a single project.

When you train a model based on a dataset, you will use Custom Training. For more information about how to configure Custom Training settings and hyperparameters, go to [Custom Training](./custom-training). Additionally, training a model this way doesn't trigger LandingLens to automatically create a snapshot, because the snapshot already exists.

To train a model on a snapshot:

1. Click the **Snapshot** icon and select **Show snapshot list**.
   <img alt="ShowSnapshotList" />
2. Select the snapshot you want to use from the **Snapshots** panel.
   <img alt="SelectSnapshot" />
3. Click **Use** and select **Train with custom options**.
   <img alt="SnapshotTrain(1)" />
4. Configure the training settings. For more information, go to [Custom Training](./custom-training).
5. Go to the **Build** page to see the model training details in the **Model** panel.

## Create New Projects from a Snapshot

You can create a new project by copying a snapshot. When you copy a snapshot, you can choose to include the existing labels, metadata, and tags.

Copying a snapshot doesn't copy project-specific settings, such as labeling tasks and project permissions.

To create a new project from a snapshot:

1. Click the **Snapshot** icon and select **Show snapshot list**.
   <img alt="ShowSnapshotList" />
2. Select the snapshot you want to use from the **Snapshots** panel.
   <img alt="SelectSnapshot" />
3. Click **Use** and select **Create new project**.
   <img alt="SnapshotNewProject" />
4. Enter a brief, descriptive name for your project in the **New Project Name** field. (You can also name the project later.)
5. Click the project type you want the new project to be.
6. If the selected project is the same type as the current project, you can select the **Include labels** checkbox to copy over the labels.
7. If you want the new project to include the metadata or [tags](./tags) from the images, select the **Include metadata** or **Include tags** checkboxes, respectively.
8. Click **Create New Project**.
   <img alt="SnapshotNewProject_2" />
9. The new project opens in a new tab. (If your browser has a pop-up blocker, you might need to deactivate it or allow it to open the tab. You might need to refresh the page in the new tab to see the new project.)

## Revert to a Snapshot

<Warning>If you've made any changes to the dataset in the Build tab since the last time you saved a snapshot, those changes will be lost if you revert to a snapshot. Changes include uploaded images, new labels, new metadata, new tags, and new label tasks. If you want to save any changes, save the dataset as a snapshot before you revert to another snapshot.</Warning>
If you are the project Owner, you can revert your dataset (in other words, the data on the **Build** tab) to a snapshot. For example, let's say that you saved a snapshot and later added more images to the dataset in the Build tab. You then decide that the new images are no longer relevant to your project, so you want to go back to the snapshot you saved. You can do this by reverting to the snapshot you saved.

After you revert to a snapshot, you can change the dataset again, including changing it to a snapshot that was created later.

Only project Owners can revert to a snapshot. The option to revert datasets does not display to other users.

To revert to a snapshot:

1. Click the **Snapshot** icon and select **Show snapshot list**.
   <img alt="ShowSnapshotList" />
2. Select the snapshot you want to revert to from the **Snapshots** panel.
   <img alt="SelectSnapshot" />
3. Click **Use** and select **Revert to this snapshot**.
   <img alt="SnapshotRevert_1" />
4. If you want to save the data on the **Build** tab as a snapshot (so that you don't lose any changes), select the **Save current project...** checkbox.
5. Click **Yes, Revert**.
   <img alt="SnapshotRevert_2" />
6. LandingLens closes the pop-up windows and loads the model you reverted to.

## Download the Dataset

<Info>The maximum dataset size that LandingLens can download is 25GB. If your dataset is larger than that, split the images in your project into multiple dataset snapshots, and then download each snapshot.</Info>
You can download the images, annotations, and defect map for the dataset as a zipped file. The format of the downloaded files allows you to upload the labeled images into other projects in LandingLens.

All downloaded datasets include a Defect Map JSON file that maps each class to a number. The folder structure of the downloaded dataset matches the project type:

* **Object Detection**: The files are downloaded in the Pascal VOC format. To understand this format and learn how to upload these files into other LandingLens Object Detection projects, go [here](./upload-labeled-images-od).
* **Segmentation**: The files are downloaded with Segmentation Masks. To understand this format and learn how to upload these files into other LandingLens Segmentation projects, go [here](./upload-labeled-images-seg).
* **Classification**: The downloaded images are grouped into folders based on class name. To learn how to upload these files into other LandingLens Classification projects, go [here](./classification).
* **Anomaly Detection**: The downloaded images are grouped into folders based on their labels: **abnormal** and **normal**. To learn how to upload these files into other LandingLens Anomaly Detection projects, go [here](./anomaly-detection).

To download the dataset:

1. Click the **Snapshot** icon and select **Show snapshot list**.
   <img alt="ShowSnapshotList" />
2. Select the snapshot you want to use from the **Snapshots** panel.
   <img alt="SelectSnapshot" />
3. Click the **Action** icon and select **Download Dataset**.
   <img alt="DownloadDataset" />
4. Your computer downloads the information as a **.tar.bz2** file, which is a compressed (zipped) folder.
5. Decompress (unzip) the file to view the file contents.

## Download Class Map

You can download the Class Map for the data in a snapshot. The Class Map is a JSON file that identifies the classes in the snapshot. You can use the Class Map to upload labeled images into Segmentation Projects in LandingLens. For more information, go to [Upload Labeled Images to Segmentation Projects](./upload-labeled-images-seg).

To download the Class Map for the data in a snapshot:

1. Click the **Snapshot** icon and select **Show snapshot list**.
   <img alt="ShowSnapshotList" />
2. Select the snapshot you want to use from the **Snapshots** panel.
   <img alt="SelectSnapshot" />
3. Click the **Action** icon and select **Download Class Map**.
   <img alt="DownloadSnapClassMap" />
4. Your computer downloads the information in a compressed (zipped) folder.
5. Decompress (unzip) the folder to view the contents.

## Download CSV

You can download a CSV of information about the dataset. The CSV includes several columns of data, including image name and split.

To download a CSV of dataset data:

1. Click the **Snapshot** icon and select **Show snapshot list**.
   <img alt="ShowSnapshotList" />
2. Select the snapshot you want to use from the **Snapshots** panel.
   <img alt="SelectSnapshot" />
3. Click the **Action** icon and select **Download CSV**.
   <img alt="DownloadSnapCSV" />
4. The file is downloaded to your computer. For a description of all data in the file, go to [CSV Data](./dataset-snapshots#csv-data).

### CSV Data

When you download a CSV of a snapshot, the file includes the information described in the following table.

| Item                | Description                                                                                                                                                                                                                                                                            | Example                                       |
| ------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------- |
| media\_id           | Unique ID assigned to the image.                                                                                                                                                                                                                                                       | 30243316                                      |
| label\_id           | Unique ID assigned to the set of labels on the image.<br />                                                                                                                                                                                                                            | 27200544                                      |
| media\_path         | The URL of where the image is stored.<br />                                                                                                                                                                                                                                            | s3://path/123/abc.jpg                         |
| bbox\_label\_path   | The URL of where the XML file with the labels is stored.<br /><br />If the image has no labels, the value is blank.                                                                                                                                                                    | s3://path/123/abc.xml                         |
| seg\_label\_path    | If the image is from a Segmentation project, this is the URL of where the [Segmentation Mask](./upload-labeled-images-seg#segmentation-mask) for the image is stored.<br /><br />If the image has no labels, or if the snapshot isn't from a Segmentation project, the value is blank. | s3://path/123/abc.png                         |
| defect\_list        | A comma-separated list of the classes labeled in the image.<br /><br />If the image has no labels, the value is `[]`.<br />                                                                                                                                                            | `['Bee', 'Moth']`                             |
| metadata            | Any metadata assigned to the image.<br /><br />If the image doesn't have any metadata, the value is `{}`.                                                                                                                                                                              | `{"Author":"Eric Smith","Organization":"QA"}` |
| split               | The split assigned to the image.<br /><br />If the image doesn't have a split, the value is blank.                                                                                                                                                                                     | train                                         |
| media\_status       | Identifies if the image is labeled or not.<br /><br /><ul><li>**approved**: The image has labels or is marked as "nothing to label".</li><li>**raw**: The image isn't labeled.</li></ul>                                                                                               | approved                                      |
| labeler\_id<br />   | The unique ID for the last user that labeled the image.<br /><br />If the image isn't labeled, the value is blank.                                                                                                                                                                     | 09ca76dd-18ab-4891-8146-52aa6aac5159<br />    |
| labeler\_name<br /> | The name of the last user that labeled the image.<br /><br />If the image isn't labeled, the value is blank.                                                                                                                                                                           | Lisa Johnson                                  |
| tags                | Any tags assigned to the image.<br /><br />If the image doesn't have any tags, the value is `[]`.                                                                                                                                                                                      | `["Camera A","BTS"]`<br />                    |

## Export a Snapshot with the API

You can export and download a snapshot with the API instead of downloading it from the app. Exporting is a two-step process: you start an export job, and then you request the download links after the job finishes.

1. Get the snapshot versions in your project with [List Snapshots](https://landing-ai.github.io/public-rest-api/fastapi/#/operations/list_snapshots_v1_projects__project_id__dataset_snapshots_get):

   ```http theme={null}
   GET /v1/projects/{project_id}/dataset/snapshots
   ```

2. Start the export job with [Post Snapshot Export](https://landing-ai.github.io/public-rest-api/fastapi/#/operations/post_snapshot_export_v1_projects__project_id__dataset_snapshots__snapshot_version__export_post):

   ```http theme={null}
   POST /v1/projects/{project_id}/dataset/snapshots/{snapshot_version}/export
   ```

3. Request the download links with [Get Snapshot Export](https://landing-ai.github.io/public-rest-api/fastapi/#/operations/get_snapshot_export_v1_projects__project_id__dataset_snapshots__snapshot_version__export_get) (for the dataset) and [Get Snapshot Metadata](https://landing-ai.github.io/public-rest-api/fastapi/#/operations/get_snapshot_metadata_v1_projects__project_id__dataset_snapshots__snapshot_version__metadata_get) (for the CSV):

   ```http theme={null}
   GET /v1/projects/{project_id}/dataset/snapshots/{snapshot_version}/export
   GET /v1/projects/{project_id}/dataset/snapshots/{snapshot_version}/metadata
   ```

   Each endpoint returns a download link and the time the link expires. Download the files before the links expire.

To get a CSV that contains download links for each image instead of storage paths, set `signedCsvInfo` to `true` in the request body. These links expire after 24 hours.

### Wait for the Export to Finish

The export job takes time to run. Until it finishes, both download endpoints return a `404` response telling you to export the snapshot first. Call the download endpoint again until it returns a download link.

<Info>Requesting a download link never starts an export job. If you skip the `POST` request, the download endpoints return `404` no matter how many times you call them.</Info>

A `404` response means the snapshot isn't ready to download. It doesn't tell you whether the export is still running or whether it failed. If a snapshot never becomes available, restart the export job by setting `retry` to `true` in the body of the `POST` request.

## Delete Snapshots

<Info>If your project is [Private](./public-and-private-projects), only the project Owner can delete snapshots.</Info>
You can delete a snapshot if you no longer need it. Deleting a snapshot cannot be undone. Deleting a snapshot doesn't delete the models and evaluation jobs run with the snapshot.

To delete a snapshot:

1. Click the **Snapshot** icon and select **Show snapshot list**.
   <img alt="ShowSnapshotList" />
2. Select the snapshot you want to delete from the **Snapshots** panel.
   <img alt="SelectSnapshot" />
3. Click the **Action** icon and select **Delete this snapshot**.
   <img alt="DeleteSnapshot_1" />
4. Click **Delete snapshot**.
   <img alt="DeleteSnapshot_2" />


# Deactivate and Reactivate Accounts
Source: https://landinglens.docs.landing.ai/deactivate-member-accounts



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✖</span></td>
    </tr>
  </tbody>
</table>

<iframe title="YouTube video player" />

Owners and Admins can deactivate member accounts at any time. This is useful when you no longer want a member to access LandingLens. For example, if a member does not work for your organization anymore, you can deactivate their account.

<Info>If an invited user cannot find their invitation to join LandingLens in their email, you can resend it. To do this, deactivate their account, and then reactivate it.</Info>

## Deactivate Accounts

To deactivate a member account:

1. Click the **User Menu** and select **Members**.
   <img alt="user_menu_members" />
2. Locate the account of the member. (You may need to search for the member to narrow down the list of users.)
3. Click the **Settings** button (vertical ellipses) and select **Deactivate Member**. The member's account is deactivated, and they can no longer access LandingLens.
   <img alt="members_deactivate" />

## Reactivate Accounts

To reactivate a member account:

1. Click the **User Menu** and select **Members**.
   <img alt="user_menu_members" />
2. Locate the account of the member. (You may need to search for the member to narrow down the list of users.)
3. Click the **Settings** button (vertical ellipses) and select **Activate Member**. The member can access LandingLens again.
   <img alt="members_reactivate" />


# December 2022 Release Notes
Source: https://landinglens.docs.landing.ai/december-release-notes



## A Note From LandingAI

| Dear LandingLens community,<br /><br />Thank you for continuing to collaborate with us on ways to improve LandingLens. Your continuous feedback and support have been central to this past year of development. Exciting things are being released over the next few weeks, and we can't wait to hear what you think! <br /><br />Thanks again for being part of the LandingLens community, and Happy Holidays!<br /><br />From,<br /> |
| -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

## Announcement

**We temporarily removed the ability to delete Classes** as we work on fixing a downstream issue it is causing with previously trained Models. We'll announce in the Release Notes when we turn this feature back on. We apologize for any inconvenience.

## What's New

* If you've already trained your Model, LandingLens will now automatically make predictions on newly uploaded images to that Model. This feature will save you time from needing to retrain your Model after you upload new images to your dataset.
* The Models sidebar is now dynamic! Previously, when you updated your Ground Truth, you needed to retrain your Model to see new updates in the Models sidebar. Now, you can update your Ground Truth, and the Models sidebar will update automatically.
* We now offer training Models with custom options so you can have granular control over pre-processing transforms and manual hyperparameter tuning.
  <img alt="Data Augmentations" />
* You can now save Models! You can then switch between Models to view their performance results.
  <img alt="Switch Models" />
* When labeling images in Object Detection Projects, you can start labeling immediately by drawing your first bounding box before you have any Classes created. After you've created your first bounding box, you can enter the name of the Class.
  <img alt="Labeling" />
* We've updated the Project creation user interface (UI)! This update is only applicable to Free Trial users.
* There are now descriptions of each Project Type to help you pick the right one.
* You can start a Project quickly by loading one of our sample datasets.

## Bug Fixes

* Fixed: We squashed a bug that prevented images from displaying on the Historical Data page. \[Internal Locator: [CL-1336](https://landingai.atlassian.net/browse/CL-1336)]
* Fixed: We made sure that the colors of the Check Label Quality suggestions match the Ground Truth labels. \[Internal Locator: [LAN-8474](https://landingai.atlassian.net/browse/LAN-8474?filter=10385)]
* Fixed: Similarly, the colors of your labels now match the Model's prediction labels. \[Internal Locator: [LAN-8386](https://landingai.atlassian.net/browse/LAN-8386)]
* Fixed: We fixed multiple bugs, so you can now upload images as expected. \[Internal Locators: [LAN-8484](https://landingai.atlassian.net/browse/LAN-8484), [LAN-8427](https://landingai.atlassian.net/browse/LAN-8427), & [LAN-8464](https://landingai.atlassian.net/browse/LAN-8464)]
* Fixed: We changed the title of the "Defects" tab to "Classes". \[Internal Locator: [LAN-8458](https://landingai.atlassian.net/browse/LAN-8458)]
* Fixed: Previously, if a device was already selected on the Live Prediction tab, users needed to select that device again when switching to the Historical Data tab. We fixed this so you can start working on your predicted images immediately. \[Internal Locator: [CL-1270](https://landingai.atlassian.net/browse/CL-1270)]
* Fixed: An error message no longer displays when you click the "Nothing to Label" button and go back to the Data Browser. \[Internal Locator: [LAN-8495](https://landingai.atlassian.net/browse/LAN-8495)]
* Fixed: Images that have the "Nothing to Label" button applied will no longer display as "Unlabeled". \[Internal Locator: [USNAP-530](https://landingai.atlassian.net/browse/USNAP-530)]


# Delete Classes
Source: https://landinglens.docs.landing.ai/delete-classes



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

When you delete a class, all labels on images for that class are also removed. If you delete a class after training your model, train it again.

<Info>Classes cannot be deleted in [Visual Prompting](./visual-prompting) projects.</Info>
<Info>If you are using the [Classic Flow](./classic-flow) version of LandingLens, the ability to delete classes is disabled by default. To have this feature enabled, contact a  representative.</Info>

<Info>Classes can't be added, deleted, or changed in Anomaly Detection projects. The available classes are Normal and Abnormal.</Info>

## Delete a Class in Manage Classes

To delete a class in the Manage Classes module:

1. Open the project you want to edit.
2. Click the **Actions** button (horizontal ellipses) and select **Manage** **Classes**.
   <img alt="DeleteClass_1" />
3. Click the class you want to delete.
4. Click **Delete**.
   <img alt="DeleteClass_2" />
5. A pop-up window displays, describing what will happen if you delete the class. Acknowledge the results by selecting the checkboxes.
6. Click **Delete Class**.
   <img alt="DeleteClass_confirm_2" />

## Delete Classes When Labeling

To delete a class when labeling an image:

1. Click the **Class** drop-down menu (or press **C**).
2. Hover over the class you want to delete.
3. Click the **i** icon that appears when you hover over the class.
   <img alt="DeleteClass_label_1" />
4. Click the **Trash** icon.
   <img alt="DeleteClass_label_2" />
5. A pop-up window displays, describing what will happen if you delete the class. Acknowledge the results by selecting the checkboxes.
6. Click **Delete Class**.
   <img alt="DeleteClass_confirm_2" />


# Delete Images
Source: https://landinglens.docs.landing.ai/delete-images



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

Let's say you accidentally uploaded some images to your project that you do not want to keep. You can remove those images from your project. To do this:

1. Select the images you want to remove.
   * To select a specific image, hover over it and click the checkbox in the upper-left corner. After you've selected one image, you can click anywhere on another image to add it to the selection.
     <img alt="RemoveImage_1" />
   * To select a range of images, hover over the first image and click the checkbox in the upper-left corner. Press **Shift** and select the last image in the range you want to select.
     <img alt="RemoveImage_2" />
   * To select all images or a page of images, click **Select** and choose either **Select All** or **Select Page**.
     <img alt="RemoveImage_3" />
2. Click **Options** in the action bar near the bottom of the screen and select **Remove from Dataset**. (You may need to scroll to see this option.) The selected images are deleted from your project.
   <img alt="RemoveImage_4" />


# Delete Projects
Source: https://landinglens.docs.landing.ai/delete-projects



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

You can only delete projects that you own. If you were invited to join a project, you will not be able to delete that project.

When you delete a project:

* You can't "undo" deleting a project.
* Any labeled images or trained models will be deleted.
* Any credits you have used for that project are still considered spent and are not refunded.
* You can create a new project in place of the deleted project.

You can delete projects in two locations: on the [main Projects page](./delete-projects#delete-projects-on-the-main-projects-page) or [within an opened project](./delete-projects#delete-an-opened-project).

<Warning>Deleting a project is an irreversible action.</Warning>

## Delete Projects on the Main Projects Page

When you're viewing all projects on the Projects page, you can delete a project. To do this:

1. Click the vertical ellipses icon on the project you want to delete.
   <img alt="Vertical-Ellipses-icon" />
2. Click **Delete**. Only project owners will see this button.
   <img alt="Delete-Button" />
3. A pop-up window displays, describing what will happen if you delete your project. Acknowledge each point by selecting the checkbox.
4. Click **Yes, Delete Project** to delete the project. This button will activate only after you have selected the checkboxes.
   <img alt="DeleteProject_2" />

## Delete an Opened Project

To delete a project that you have opened:

1. Click **Settings** in the left sidebar.
2. Click the **Administrative** tab.
3. Click **Delete Project**. Only project owners will see this button.
   <img alt="DeleteProject_1" />
4. A pop-up window displays, describing what will happen if you delete your project. Acknowledge each point by selecting the checkbox.
5. Click **Yes, Delete Project** to delete the project. This button will activate only after you have selected the checkboxes.
   <img alt="DeleteProject_2" />


# Deployment Options
Source: https://landinglens.docs.landing.ai/deployment-options



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

After you are happy with the results of your trained model, you are ready to use it! To use a model, you **deploy** it, which means you put the model in a virtual location so that you can then upload images to it. When you upload images, the model runs **inferences**, which means that it detects what it was trained to look for.

## Deployment Options

There are a few ways to deploy your LandingLens model:

* [Cloud Deployment](./cloud-deployment): Deploy your model to a virtual environment hosted within the LandingLens app. Use API calls or  to send images to your model. If using , the LandingLens app exists within your Snowflake environment, so the model will be hosted in Snowflake.
* [LandingAI Deploy Docker](./landingedge/docker-deploy): Download our Docker image to create a Dockerized container. Deploy your model and run inference in this self-hosted container. You must first [activate](./activate-projects) a project to deploy its models with Docker.
* [LandingEdge](https://support-landingai.document360.io/docs/landingedge-overview): Use the LandingEdge application to communicate with edge devices, industrial cameras, and programmable logic controllers (PLCs). You must first [activate](./activate-projects) a project to deploy its models with LandingEdge.

| Attribute  | Cloud Deployment | Container Deployment | LandingEdge |
| ---------- | ---------------- | -------------------- | ----------- |
| Latency    | High             | Low                  | Low         |
| Throughput | Configurable     | 30 FPS               | 30 FPS      |
| Pricing    | Per inference    | Free                 | Free        |

<Info>For Enterprise users,  can hide the LandingEdge and Docker deployment options if you don't want your organization to deploy using these methods. To have these disabled, contact [support@landing.ai](mailto:support@landing.ai).</Info>

### When to Use Cloud Deployment

**Cloud Deployment** is a scalable and cost-effective deployment solution. It can accommodate surges in inference traffic up to a configurable rate limit, with charges incurred per inference. Cloud Deployment is a preferred option for managing variable inference loads.

Use Cloud Deployment if you:

* Want to start running inference without purchasing GPU machines or managing deployments.
* Have a good network connectivity from your inferencing point to the cloud.

### When to Use Docker Deployment

**Docker Deployment** is the most flexible deployment option for developers that build mission-critical solutions or process high-throughput continuous inference loads. It can be deployed in your private cloud, on-premises, or at the edge.

Use Docker Deployment if you:

* Have a deployment infrastructure and want to add inferencing capabilities to it.
* Are looking for deployment automation in a container-based infrastructure.

### When to Use LandingEdge

**LandingEdge** is an application that lets you deploy to an edge computer, such as an industrial PC.

Use LandingEdge if you:

* Want to build machine vision solutions using specialized hardware, like industrial cameras and PLCs.
* Want to build mission-critical solutions at the edge.

## Compare Deployment Options

Use the table below as a reference when choosing a deployment option.

| **Feature**                                             | **Cloud Deployment**        | **Docker**                          | **LandingEdge**                                      |
| ------------------------------------------------------- | --------------------------- | ----------------------------------- | ---------------------------------------------------- |
| **General**                                             |                             |                                     |                                                      |
| Hosting                                                 | LandingLens-hosted          | Self-hosted                         | Self-hosted                                          |
| Operating system                                        | Linux, Mac, Windows         | Any                                 | Linux, Windows                                       |
| Can run inference when not connected to the internet    | ✖                           | ✓                                   | ✓                                                    |
| Can run inference on Visual Prompting models            | ✓                           | ✖                                   | ✖                                                    |
| Can see live results in the user interface              | ✓                           | ✖<br />(there is no user interface) | ✓                                                    |
| Can upload image metadata to images                     | ✓                           | ✓                                   | ✓                                                    |
| Maximum inference calls per minute                      | 40                          | Depends on system                   | Depends on system                                    |
| Can communicate with PLCs                               | ✖                           | ✖                                   | ✓                                                    |
| Can deploy on NVIDIA Jetson devices                     | ✖                           | ✓                                   | ✖                                                    |
| Can deploy on ARM64 processors                          | ✖                           | ✓                                   | ✖                                                    |
| Running inference consumes [credits](./plans#credits)   | ✓                           | ✖                                   | ✖                                                    |
| **Send Images for Inference**                           |                             |                                     |                                                      |
| Drag and drop images                                    | ✓                           | ✖                                   | ✓                                                    |
| GenICam                                                 | ✖                           | ✖                                   | ✓                                                    |
| Images from webcam                                      | ✓                           | ✖                                   | ✖                                                    |
| Video (will convert to images)                          | ✓<br />(via Python library) | ✖                                   | ✓                                                    |
| Select from a designated folder (folder watcher)        | ✖                           | ✖                                   | ✓                                                    |
| Send images via POST APIs                               | ✓                           | ✓                                   | ✓                                                    |
| **Post-Inference Features**                             |                             |                                     |                                                      |
| Apply post-processing scripts                           | ✓<br />(via Python library) | ✓<br />(via Python library)         | ✓                                                    |
| Can view inferenced images & predictions in LandingLens | ✓                           | ✓<br />(must pass `--upload` flag)  | ✓<br />(must enable "Upload results to LandingLens") |
| Can save inferenced images to a local folder            | ✖                           | ✖                                   | ✓                                                    |

<Info>The only deployment option for  is [Cloud Deployment](./cloud-deployment).</Info>


# Download Models
Source: https://landinglens.docs.landing.ai/download-models



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

Models can be deployed directly through LandingLens by using Cloud Deployment. If you want to run your model offline (that is, NOT through the LandingLens cloud endpoint), you can download the model. The downloaded model is a zipped folder that contains an ONNX file and supporting documents.

When you download a model, you can:

* Deploy it offline using [LandingEdge](./landingedge/landingedge-overview), our edge deployment solution.
* Deploy it offline using the [LandingAI Docker Deployment](./landingedge/docker-deploy) solution, which empowers you to run model inference programmatically.
* Deploy it using an application that you or your organization developed.
* Deploy it using a third-party application.
* Keep a copy of your model for archival or versioning purposes.

## Considerations Before Downloading Models

Before downloading models, read through and understanding the following information:

* [Activate Projects](./download-models#activate-projects)
* [Commercial vs. Noncommercial Use](./download-models#commercial-vs-noncommercial-use)
* [ONNX Runtime Doesn't Support Models Trained with a RepPoints Architecture](./download-models#onnx-runtime-doesnt-support-models-trained-with-a-reppoints-architecture)

### Activate Projects

A project must be “active” before you can download models from it. Activating a project means that you can download models from it. Each pricing plan has a maximum number of projects that can be active at the same time.

Owners and Admins can activate a project on the [Active Projects](./activate-projects) page. Or, if any user (including a Collaborator) tries to download a model and the project hasn’t been activated yet, they will be prompted to activate the project. (In , any user can access the **Active Projects** page and activate projects.)

To learn how to activate projects, go to [Activate Projects](./activate-projects).

### Commercial vs. Noncommercial Use

If you’re on the Free or Visionary plan, downloaded models can only be used for noncommercial use. “Noncommercial” means not primarily intended for or directed towards commercial advantage or monetary compensation.

### ONNX Runtime Doesn't Support Models Trained with a RepPoints Architecture

All models downloaded from LandingLens can be deployed via LandingEdge and the LandingAI Docker solution.

However, deploying with ONNX Runtime has this limitation: ONNX Runtime does not support Object Detection models trained with a **RepPoints** architecture. Using one of these models will cause an error similar to:

```python theme={null}
failed:Fatal error: org.openvinotoolkit:DeformableConv2D(-1) is not a registered function/op
```

If you plan on using a downloaded Object Detection model with ONNX Runtime, use Custom Training and select **RtmDet-\[9M]** as the **Model Size**. For more information, go to [Custom Training](./custom-training).

<img alt="RtmDet-9M" />

## Download Models

To download a model:

1. [Activate the project](./activate-projects) that you want to download models from, if you haven't already.
2. Open the project to the **Models** tab.
3. Locate the row for the model you want to download.
4. Click the **Actions** icon ( **…**) and select **Download Model**.
   <img alt="download_model_2024" />
5. The model is downloaded as a ZIP file.

## How to Use a Downloaded Model

Downloaded models are zipped folders that have names similar to **bundle\_5924eb6b-a1ee-4009-8231-695bc1e5bdde.zip**.

If you want to use the model in an offline deployment of [LandingEdge](./landingedge/manage-inspection-points) or [Docker](./landingedge/docker-deploy), leave the folder zipped. LandingEdge and Docker will load the full ZIP file.

If you'd like to use the model elsewhere, unzip the folder and locate the **saved\_model.onnx** file (**folder** > **model** > **saved\_model.onnx**). ONNX (Open Neural Network Exchange) is an open source format for AI models. Since they are open source, ONNX files can be used and deployed with different frameworks, tools, and hardware.

The other files are in the ZIP file (dm.json, meta.json, etc.) are specific to LandingLens.

<Info>If you created a model using"large images"via Custom Training, use the`saved_model_tiled.onnx`file.</Info>


# Drag and Drop Images
Source: https://landinglens.docs.landing.ai/drag-and-drop-images



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

To drag and drop images directly into a project:

1. Open the project you want to upload images to.
2. If you haven't uploaded any images to the project yet, drag and drop files directly into the project. LandingLens immediately uploads the images.
   <img alt="DragAndDrop_low(1)" />
3. If you've already uploaded images, click the **Upload** icon.
   <img alt="Upload_ProjectWithImages" />
4. Drag and drop files into the Upload pop-up window.
   <img alt="DragDrop_1" />
5. Click **Upload**.
   <img alt="DragDrop_2" />
6. LandingLens uploads the images to your project.


# Embed-Optimized Models
Source: https://landinglens.docs.landing.ai/edge-ai



LandingLens supports building and deploying **embed-optimized models**, which are lightweight, efficient computer vision models designed to run directly on embedded devices.

To create an embed-optimized model, choose one of the following model architectures when running [Custom Training](./custom-training):

* **For Object Detection**: ODEmbedded-\[23M]
* **For Classification**: ConvNextEmbedded-\[16M]

Using these architecture types generates a TensorFlow Lite (TFLite) model ready for embedded deployment. After downloading an embed-optimized model from LandingLens, you can interact with it using TFLite libraries and APIs.

<Info>LandingLens doesn't support embed-optimized models for Segmentation, Anomaly Detection, or  projects.</Info>

## When to Use Embed-Optimized Models

Embed-optimized models are designed for scenarios where you're deploying to devices with limited compute power, restricted memory, or no network connection. These models are a good fit if your application needs:

* Faster inference times on constrained hardware
* Smaller model sizes that fit within embedded memory limits
* Offline capabilities for real-time inference without a network connection
* Deployment to mobile devices, IoT endpoints, robots, or edge cameras

<Info>If you don't need to run your model on embedded hardware, use our other model architectures, which are optimized for cloud and general-purpose edge deployment.</Info>

## Example Use Cases

There are many scenarios where running computer vision models directly on embedded devices offers real advantages—such as lower latency, offline operation, and reduced hardware costs. Here are a few real-world use cases for LandingLens embed-optimized models:

* **Utility drones for aerial inspection**: A utility company uses drones to detect damaged power lines after a storm. The LandingLens embed-optimized model runs directly on the drone’s onboard chipset, allowing real-time analysis without needing a cloud connection.
* **Smartphone app for plant classification**: A mobile app uses a LandingLens embed-optimized model to identify plant species from photos taken by users. Running the model directly on the phone means users get fast predictions, even when offline.
* **Manufacturing line quality control**: A factory installs embedded cameras on an assembly line. The cameras have LandingLens embed-optimized models that detect defects. The model's fast inference helps catch issues early, without needing an external server or latency-prone connection.
* **Smart city info kiosks**: Public kiosks in a smart city use LandingLens embed-optimized models to classify visitor behavior (like approaching the kiosk) to trigger helpful content or assistance. The model runs efficiently on low-power hardware inside each kiosk.
* **Autonomous delivery robots**: A robotics company deploys LandingLens embed-optimized models in delivery bots to detect pedestrians and navigate around obstacles. Lightweight, local inference helps the bot respond quickly in real-world environments.

## Deployment Support

The LandingLens embed-optimized models are built for flexible deployment to **embedded systems that support TensorFlow Lite (TFLite) inference**.

LandingLens provides the model architecture and TFLite export format, allowing you to integrate the model into your own applications or pipelines. Because every embedded deployment is different, you’ll need to customize your solution based on your device, hardware accelerators, and software stack.

We recommend thoroughly testing your setup before deploying to production.

### LandingAI Edge Applications

While embed-optimized models are intended for custom embedded deployments, you can use LandingEdge and LandingAI Docker to test your models without writing custom code. These tools are a convenient way to validate performance and output before integrating with your production environment.

Supported versions:

* LandingEdge 2.11.79 and later
* LandingAI Docker 2.11.79 and later

### LandingAI Cloud Deployment

The LandingLens embed-optimized models **are not designed for cloud deployment**. Their architecture is tuned for fast inference on constrained devices, prioritizing low latency over high accuracy.

For cloud use cases, we recommend using other LandingLens model architectures.

## Model Information

For the embed-optimized models, both the model input and output are quantized to int8. The models are fully quantized per-tensor and model training performs static quantization, which means that both weights and activations are quantized.

The models are calibrated using Quantization Aware Training (QAT).

The following table describes key data points for the LandingLens embed-optimized models.

| Description                      | Object Detection                                                                                                                                                                                                                                      | Classification                     |
| -------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------- |
| Architecture name in LandingLens | ODEmbedded-\[23M]                                                                                                                                                                                                                                     | ConvNextEmbedded-\[16M]            |
| Trainable parameters             | 23M                                                                                                                                                                                                                                                   | 16M                                |
| Input shape                      | BHWC (1, height, width, channel)                                                                                                                                                                                                                      | BHWC (1, height, width, channel)   |
| Model format                     | TensorFlow Lite (TFLite)                                                                                                                                                                                                                              | TensorFlow Lite (TFLite)           |
| Model input                      | (1, height, width, channel), int8                                                                                                                                                                                                                     | (1, height, width, channel), int8  |
| Model output                     | <ul><li>scores: (1, num\_detections), int8</li><li>bboxes: (1, num\_detections, 4), int8, in (x\_min, y\_min, x\_max, y\_max) format</li><li>labels: (1, num\_detections), int64 (some devices will move this tensor to CPU to generate it)</li></ul> | scores: (1, num\_detections), int8 |

## Quickstart: Train and Deploy Embed-Optimized Models

The process for creating an embed-optimized model is similar to creating other models in LandingLens. This quickstart highlights the key steps in the process. For detailed instructions, we’ve included links to the relevant parts of the documentation.

1. Create an Object Detection or Classification [project](./create-projects).
2. [Upload](./upload-images) and label your images.
3. Train a [Custom Model](./custom-training) using the settings listed in the [Training Settings](./edge-ai#training-settings) table.
4. [Activate](./activate-projects) the project.
5. [Download](./download-models) the model. The downloaded model is a ZIP file that has the prefix **bundle\_**.
6. Use TFLite libraries and APIs to write a script that runs the downloaded model.
7. Load the model and script to the embedded device. (Do not unzip the downloaded model.)

### Training Settings

Embed-optimized models are created with [Custom Training](./custom-training). Use these settings when configuring your Custom Training job.

| Setting                                         | Object Detection                   | Classification                         |
| ----------------------------------------------- | ---------------------------------- | -------------------------------------- |
| Model size                                      | ODEmbedded-\[23M]                  | ConvNextEmbedded-\[16M]                |
| Minumum epochs                                  | 300 epochs                         | 100 epochs                             |
| Minimum dimensions<br />(for resize or rescale) | 4096px (for example: 64x64px)      | 4096px (for example: 64x64px)          |
| Maximum dimensions<br />(for resize or rescale) | 541,696px (for example: 736x736px) | 1,478,656px (for example: 1216x1216px) |

### Recommended Number of Images

We recommend using at least 100 labeled images for training embed-optimized models. The model might not train correctly with fewer images.

### Epochs

Embed-optimized models typically require more training epochs than other model types to achieve good performance. Using too few epochs may prevent the model from converging or learning effectively.

We recommend the following minimums:

* Object Detection: At least 300 epochs
* Classification: At least 100 epochs

### Learning Loss Spikes During Training

In some cases during training, the [loss curve](./train-models#view-learning-data-during-model-training) might spike and the model convergence degrade. This results in a model with low performance, such as an F1 score of 30%. If you notice the loss curve spikes or the model performance is low, try training the model again.

## Low Confidence Scores (Object Detection)

After training an embed-optimized Object Detection model, the highest confidence score for a prediction might be 0.5. The low confidence score is due to a quantization limitation, and does not mean that the model performs poorly.

Adjust the [confidence threshold](./view-predictions#confidence-threshold) to find the optimal between accurate false positives and false negatives.

## Sample Scripts: Run Inference with Embed-Optimized Models

Get sample scripts for running inference with embed-optimized models in our Python library [here](https://github.com/landing-ai/landingai-python/tree/main/examples/edge-models).


# Edit Project Names
Source: https://landinglens.docs.landing.ai/edit-project-names



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

To edit a project name:

1. Open the project you want to edit.
2. Click the **Edit** icon.
   <img alt="ProjectName_1" />
3. Enter a brief, descriptive name for your project in the field.
   <img alt="ProjectName_2" />
4. Click anywhere on the page to save your change.


# Markdown mri report
Source: https://landinglens.docs.landing.ai/examples/markdown-mri-report



Summary : This image is a logo for the website USARAD.com, featuring stylized text over a blue globe graphic.

logo: USARAD.com

Main Elements :
• The logo consists of the text "USARAD.com" superimposed on a blue globe.
• "USA" is rendered in white with a pattern of blue stars.
• "RAD" is in bold red capital letters.
• ".com" is in smaller, italicized white letters with a blue outline, positioned to the right of "RAD".
• The globe background shows a stylized map of the world with light blue network lines crossing it.

Design & Placement :
• The text "USARAD.com" is centered horizontally across the globe.
• The globe is shaded with gradients of blue and includes faint outlines of continents.
• The network lines suggest connectivity or a digital/technological theme.

Analysis :
• The logo combines patriotic US imagery (stars, "USA") with a global and technological motif (globe, network lines), likely representing a US-based radiology or medical imaging company with international reach.
• The use of bold red for "RAD" emphasizes the radiology aspect, while the globe and network lines suggest worldwide service or telemedicine.

2601 E. Oakland Park Blvd, Suite 102 Ft. Lauderdale, FL  33306 Phone: 888.886.5238  Fax: 888.886.5221

Patient: DOE, JOHN
MRN : JD4USARAD
Referring Physician: DR. DAVID LIVESEY

Exam Date:  05/20/2010
DOB:  01/01/1961
FAX:  (305) 418-8166

MRI OF THE LUMBAR SPINE WITH AND WITHOUT CONTRAST

PROCEDURE:
MRI of lumbosacral spine without/with IV contrast.

INDICATION:
Radiculopathy post L2-L3 fusion, question incomplete fusion. Persistent symptoms.

COMPARISON:
None.

TECHNIQUE:
Multiplanar and multi-sequence imaging of the lumbosacral spine without/with intravenous contrast using a 0.3T MRI scanner.

FINDINGS:
Postoperative findings of posterior intrapedicular spinal fusion at L2-L3 noted. The L2-L3 disk is preserved. Enhancing peridural fibrosis noted at L2-L3 level mildly deforming the thecal sac with dominant extrinsic impression on the right lateral thecal sac. Non enhancing cystic foci noted along the posterior elements representing small pseudomeningoceles. Postoperative fusion and laminectomy noted at L4-L5 level with osseous fusion anteriorly. Osseous hypertrophy of the posterior elements noted at L4 and L5. Lumbar lordosis is decreased. Multilevel endplate, disk and facet degenerative changes noted. Conus medullaris terminates at approximately mid L1 vertebral body level.

L1-L2 shows moderate broad-based disc bulging contributing to mild to moderate left greater than right neuroforamina narrowing. Spinal canal is grossly patent. Approximately 2 mm L1 on L2 retrolisthesis noted.

L2-L3 shows moderate nonenhancing bi foraminal broad-based disk bulging contributing to mild-to-moderate right greater than left neural foramina narrowing. Moderate acquired spinal canal stenosis noted due to enhancing peridural fibrosis with asymmetric more focal extrinsic impression on the right lateral ventral thecal sac. Negligible spondylolisthesis of L2 on L3 noted.

L3-L4 level shows mild disk desiccation and height loss. Extraforaminal focal annular tears noted on both sides. Spinal canal and foramina are patent.

Page 1 of 2

Summary : This is a logo for USARAD.com, featuring the company name overlaid on a stylized globe.

logo: USARAD.com

Company Name & Tagline :
• Text reads “USARAD.com”.
• “USA” is in white with a blue star pattern.
• “RAD” is in bold red.
• “.com” is in white with a blue outline.

Graphic Elements :
• Background is a blue globe with visible continents and light blue network lines crossing it.
• The globe is shaded to give a 3D effect.

Dimensions & Placement :
• The text “USARAD.com” is centered horizontally across the globe.
• The globe is circular and occupies the majority of the logo space.

Analysis :
• The logo uses a globe and network lines to suggest global reach and connectivity.
• The colour scheme (blue, white, red) evokes the US national colours, reinforcing the brand identity.
• The bold “RAD” highlights the radiology focus of the company.

2601 E. Oakland Park Blvd, Suite 102 Ft. Lauderdale, FL 33306 Phone: 888.886.5238  Fax: 888.886.5221
──────────────────────────────────────────────

Patient: DOE, JOHN
MRN : JD4USARAD
Referring Physician: DR. DAVID LIVESEY

Exam Date:  05/20/2010
DOB:  01/01/1961
FAX:  (305) 418-8166

L4-L5 level shows postoperative findings with partial fusion anteriorly with linear hyper intense signal in the remaining intervertebral disk space. Spinal canal and foramina are patent. No gross thecal sac deformity noted. Bilateral laminectomies noted.

L5-S1 level shows subtle left central broad-based disk protrusion. Spinal canal and foramina are patent. No gross thecal sac deformity. Bilateral laminectomies noted.
Ferromagnetic susceptibility artifact noted along the mid posterior back spanning from L2 through S2.

No suspicious prevertebral or posterior paraspinal soft tissue signal abnormality noted.
Mild subchondral sclerosis of the included sacroiliac joints noted.
Incidental note of overdistended bladder.

IMPRESSION:

1. Postoperative findings of posterior spinal intrapedicular fusion at L2-L3 level. L2-L3 shows moderate nonenhancing bi foraminal broad-based disk bulging contributing to mild-to-moderate right greater than left neural foramina narrowing. Moderate acquired spinal canal stenosis noted due to enhancing peridural fibrosis with asymmetric more focal extrinsic impression on the right lateral ventral thecal sac. Negligible spondylolisthesis of L2 on L3 noted. Non enhancing cystic foci noted along the posterior elements representing small pseudomeningoceles.

2) Postoperative fusion and laminectomy noted at L4-L5 levels with osseous fusion anteriorly. Osseous hypertrophy of the posterior elements noted at L4 and L5.

3. L5-S1 level shows subtle left central broad-based disk protrusion. Spinal canal and foramina are patent. No gross thecal sac deformity.

Note that the stability of findings cannot be determined in the absence of prior imaging for comparison/correlation.
Correlation with prior imaging is advised to document stability of findings described.

-Electronically Signed by: RADIOLOGIST, ADMIN  on

06/07/2010 1:22:01 PM

Page 2 of 2


# Markdown wire transfer
Source: https://landinglens.docs.landing.ai/examples/markdown-wire-transfer



WIRE TRANSFER FORM

Invoice Information

Invoice Description: Professional consulting services - Q3 2025

Total Invoice Amount: \$15,750.00 USD

Beneficiary Bank Information

Bank Name: JPMorgan Chase Bank, N.A.

Bank Address: 270 Park Avenue, New York, NY 10017, USA

Bank Account Number: 4578923456789012

SWIFT Code: CHASUS33

ABA Routing Number: 021000021

ACH Routing Number: 021000021

Invoice Line Items
<table><thead><tr><th>Description</th><th>Amount</th></tr></thead><tbody><tr><td>Strategic planning consultation (40 hours @ $150/hr)</td><td>$6,000.00</td></tr><tr><td>Market analysis report preparation</td><td>$3,500.00</td></tr><tr><td>Implementation roadmap development</td><td>$2,250.00</td></tr><tr><td>Executive presentation materials</td><td>$1,500.00</td></tr><tr><td>Follow-up consultation sessions (15 hours @ $150/hr)</td><td>$2,250.00</td></tr><tr><td>Travel expenses (reimbursable)</td><td>$250.00</td></tr><tr><td>TOTAL</td><td>\$15,750.00</td></tr></tbody></table>

Wire Transfer Instructions

Payment Method: International Wire Transfer
Currency: USD (United States Dollars)
Beneficiary Name: ABC Consulting Services LLC

**Beneficiary Address:** 1234 Business Park Drive, Suite 500, Los Angeles, CA 90210, USA

**Purpose of Payment:** Payment for professional consulting services as per Invoice #INV-2025-0847

* Special Instructions:
  * Please include invoice number INV-2025-0847 in the payment reference
  * All bank charges to be borne by the sender
  * Payment should be received within 3-5 business days
  * Please send wire confirmation receipt to [accounting@abcconsulting.com](mailto:accounting@abcconsulting.com)
  * For any questions regarding this transfer, contact: +1 (555) 123-4567

**Urgency:** Standard processing (3-5 business days acceptable)

Form completed on: September 3, 2025

Reference Number: WT-2025-0847


# Failed Models
Source: https://landinglens.docs.landing.ai/failed-models



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

If the model training process fails, you can access more information about that failure to help you troubleshoot. Each project has a **Failed Jobs** page that shows a list of model training processes that failed in the past 7 days.

To access a project's Failed Jobs page:

1. Open the project to the **Models** tab.
2. Click the **Actions** (...) icon and select **Failed Jobs**.
   <img alt="FailedJobs_1" />
3. Information about model training jobs that failed in the past 7 days displays.
   <img alt="FailedJobs_2" />


# Grant LandingLens Access to Stages
Source: https://landinglens.docs.landing.ai/grant-landinglens-access-to-stages



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✖</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

Some SQL commands for managing  require you to grant LandingLens access to Snowflake stages.

The processes that require LandingLens to have access to stages include:

* [Run inference on staged images with SQL commands](./run-inference-with-sql-commands)
* [Load images from Snowflake stages](./load-images-from-snowflake)

## Grant LandingLens Access to a Stage

To grant LandingLens access to a stage:

1. Make a note of the **database**, **schema**, and **stage** that you want to give LandingLens access to.
2. Locate the name of your instance of LandingLens. For instructions on how to do this, go [here](./app-name).
3. Open [Snowsight](https://app.snowflake.com).
4. Create a new worksheet and run the following SQL commands. Replace these placeholders with your information: `YOUR_DB`, `YOUR_SCHEMA`, `YOUR_STAGE`, and `<APP_NAME>`.

```bash theme={null}
GRANT USAGE ON DATABASE YOUR_DB TO APPLICATION <APP_NAME>;
GRANT USAGE ON SCHEMA YOUR_DB.YOUR_SCHEMA TO APPLICATION <APP_NAME>;
GRANT READ ON STAGE YOUR_DB.YOUR_SCHEMA.YOUR_STAGE TO APPLICATION <APP_NAME>;
```


# Heatmaps
Source: https://landinglens.docs.landing.ai/heatmaps



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

<iframe title="YouTube video player" />

After training a Classification or Anomaly Detection model, turn on the **Heatmap** setting to see what specific characterstics the model used to make its predictions. A heatmap shows which parts of an image contributed most to the model’s decision.

To see heatmaps, turn on the **Heatmap** toggle.

<img alt="heatmap_toggle_04_07_2025" />

## Heatmap Colors: Classification

For Classification projects, heatmaps show color intensity to reflect the activation points, which are the specific locations in the heatmap that indicate high activity or interest. The following colors show the degree to which each area contributed to the class being assigned, *from most impactful to least impactful*:

* Yellow: High impact
* Orange
* Purple: Low impact
* Gray: No impact

There are several gradients within each color.

The image below shows a heatmap of a model that detects bicycles. According to the heatmap, the wheels of the bicycle influence the model’s prediction the most.

<img alt="DefectHeatMap_Yes" />

## Heatmap Colors: Anomaly Detection

For Anomaly Detection models, the heatmap is a color-coded overlay that indicates which areas the model considers to be “abnormal”.

The level of brightness indicates how “abnormal” the model thinks the area is, with a brighter color meaning the area is more abnormal.

For example, in the image below, the overlay on the bottom knob is bright. This means this knob’s position impacted the model’s “Abnormal” prediction the most. And the model is correct: the knob is pointing down, but it should be pointing right.

<img alt="heatmap_AD_04_07_2025" />

## Why Are Heatmaps Only in Classification and Anomaly Detection Projects?

Since Classification and Anomaly Detection models classify images as a whole, it’s important to understand what features in those images prompted a model to make its predictions.

In other project types, you can refer to the model’s labels or predictions, which implicitly indicate the areas the model is focused on. For example, Object Detection has bounding boxes that can provide this information.

## Heatmaps Display Only for Images Included in Training

Heatmaps only display for images included in the dataset at the time of training.

If you add images after training a model, you must train a model again in order to see heatmaps for those images.


# Predictions on the Deploy Page and Continuous Learning
Source: https://landinglens.docs.landing.ai/historical-data



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

When you deploy a model and then use it to run inference on images, you can view those images and the prediction information on the **Deploy** page. You can also save these images to your dataset so that you can then update your model with the newest information. This process is called continuous learning, and it allows you to fine-tune your model as you get results from real-world scenarios.

To maintain accurate recordkeeping, images cannot be deleted from the Deploy page.

<img alt="historical_data" />

<Info>In earlier versions of LandingLens, this section was called "Historical Data".</Info>

## When Are Predicted Images Saved to the Deploy Page?

Images are saved to the Deploy page when:

* You run inference via Cloud Deployment.
* You enable **Upload Results to LandingLens** for an Inspection Point in [LandingEdge](./landingedge/manage-inspection-points).
* You include the `--upload` flag when deploying a model using [Docker Deployment](./landingedge/docker-deploy).

Images are NOT saved to the Deploy page when:

* You use the **Try this model** tool. This tool is designed to test your model before it's deployed in a production environment. Including test results could skew your production data. (For legacy "classic" workflow users, this section DOES includes results from the **Predict** tool.)

## Save Predicted Images to Your Dataset (Continuous Learning)

<iframe title="YouTube video player" />

You can save predicted images to your dataset (the Build tab) to train a model with those images. For example, let's say that you have a model trained to detect hardware in cereal, but the model did not detect a screw in some images. You can save these images to your dataset, label them, and then retrain your model. This process is called **continuous learning**.

To ensure that all labels are accurate and approved by your team, **saving images to your dataset does not save the predictions as labels**. Images saved from the Deploy page to your dataset are marked as "unlabeled". Label the images and train a new model to incorporate the new information into a model.

To save images from the Deploy page to your dataset:

1. Go to the **Deploy** page.
2. Click the deployment you want to see the results for in the **Cloud Deployment** or **Self Hosted Deployment** section.
   <img alt="continuousLearning_1" />
3. Select the images you want to save to your dataset.
4. Click **Add Images to Build**.
   <img alt="continuousLearning_2" />
5. LandingLens saves those images to the dataset. Go to the **Build** tab and see the new images. You can now label the images and train a new model.
   <img alt="continuousLearning_3" />
6. Back on the **Deploy** page, the image statuses change from **Raw** to **In Sync**.

### Image Statuses

Images on the Deploy page have one of these status: **Raw** and **In Sync**.

* **Raw** means that the image is the original that was uploaded to the project.
* **In Sync** means that the image was sent to the Build tab.

<Info>There is a known issue that causes the status to not always change to **In Sync**. The LandingAI team is evaluating this issue.</Info>

## Image Detail Settings

Click an image on the Deploy page to see more image and prediction details. The image and table below describe the key elements of the Image Details pop-up window.

<img alt="Image Details" />| # | Element | Description |
\| --- | --- | --- |
\| 1 | Toggle Full-Screen / Exit Full-Screen | Enters and exits the full-screen mode. |
\| 2 | Image Enhancement | Manually adjust the brightness and contrast. Or choose an option to add enhancements automatically. These options are useful if an image is too dark and you want to brighten it so you can better see the details of the image. |
\| 3 | Show Labels | Toggle on and off the labels on the image. This is useful if you want to search the image for any missed objects of interest. |
\| 4 | Directional Keys | Navigate to the next or previous image. |
\| 5 | Hotkeys | View a list of all the available hotkeys (keyboard shortcuts). |
\| 6 | Close Window | Close the Image Details pop-up window. |
\| 7 | Confidence Score | If the model detects items in an image, the Confidence Score displays. The Confidence Score represents how confident the model is that its prediction is correct. For example, in the screenshot above, the model is 19% (0.19) and 17% (0.17) confident that the items detected are screws. |
\| 8 | Information | If you used an API to upload metadata, that metadata will display in this section. The **Media ID** is generated internally in the database. |
\| 9 | Human Judgment | Data populates in this section after you or someone else [marks a Prediction as "Correct" or "Incorrect](./agreement-based-labeling#review-submitted-labeling-tasks)".<ul><li>**Inspector ID**: The user's email address who marked the Prediction.</li><li>**Judgment**: Displays **OK** if the prediction is correct or **NG** (short for "not good") if the prediction is incorrect.</li><li>**Comment**: Displays any feedback left by the user who reviewed the prediction.</li></ul> |
\| 10 | Download | Download the original image. This image will not show any predictions. |
\| 11 | Correct/Incorrect | Allows users to mark predictions as "Correct" or "Incorrect." |


# Image Capture Best Practices
Source: https://landinglens.docs.landing.ai/image-best-practices



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

LandingLens is built on a data-centric approach. This means that having a dataset of high-quality images is more important than finetuning model parameters. This also means that **it’s better to have fewer high-quality images than many poor-quality ones**.

A dataset is the foundation of a model in LandingLens. Therefore, you’re more likely to build a high-perforing model if you start with a dataset of high-quality images.

Choosing the right hardware—cameras, lenses, and lighting—is one component to creating high-quality images. Thinking about the dataset as a whole in the context of your use case and goals is another component.

To learn how to build a high-quality dataset, check out the best practices in the following articles:

* [Cameras](./cameras)
* [Lenses (Optics)](./lenses)
* [Lighting](./lighting)
* [Curate High Quality Datasets](./curate-high-quality-datasets)
* [Image Pre-Processing](./image-pre-processing)

## What Cameras, Lenses, and Lighting Should I Use?

Implementing a camera, lens, and lighting setup is important to ensure that all images yield consistent and accurate results. There is generally no one-size-fits-all solution, and different use cases require application-specific imaging geometries consisting of a camera, lens, and lighting.

Check out the rest of the article for more details, but to ensure that you get the right camera, lens, and lighting system for your specific use case, we recommend working with one of our [LandingLens Certified Partners](https://landing.ai/hardware-partner-networks). Their area of expertise is developing these types of solutions, and they can offer their real-world experience to help you implement the hardware that's right for you.

All partners have gone through our rigorous vetting program and are industry-trusted experts. To learn more about our partners, go [here](https://landing.ai/hardware-partner-networks).

## How Having the Hardware Sets You Up for Success

The guiding principle in developing your camera, lens, and lighting system is that it should lead to *reliable* and *repeatable* results. Good data in leads to good data out.

The goal when selecting imaging hardware is to create visible contrast between the object and the background with a defined geometry. This is achieved by:

* Defining a camera's field of view (area of inspection),
* Identifying the working distance from the front of the lens to the object, and
* Selecting an appropriate lighting technique that creates contrast.


# Image Pre-Processing
Source: https://landinglens.docs.landing.ai/image-pre-processing



To get optimal predictions from computer vision models, it’s important that the object or region of interest is clearly visible in your images. In some cases, pre-processing your images before uploading them to LandingLens can help models detect key features more effectively.

Below are some common pre-processing techniques to consider. These tips won’t apply to every use case, but they can make a meaningful difference in how well the model detects objects of interest in your images.

Be sure to apply any pre-processing steps consistently across your entire dataset—including both your training images and the ones you use for inference.

## Resize Images

LandingLens automatically resizes images during training based on the project type (for [Fast Training](./train-models)) or based on your settings (for [Custom Training](./custom-training)). This helps standardize inputs and speeds up training. For detailed information, go to [Images Are Resized During Model Training](./train-models#images-are-resized-during-model-training).

If the object of interest is small or the image has a noisy background, the automatic resize might shrink the object too much, which can make it harder for the model to "see" what it should learn. In this situation, consider resizing and/or cropping images before uploading them to LandingLens to make objects of interest more prominent.

## Crop Images

If your images include a lot of background, and the object of interest is consistently in the same location, consider cropping the images to bring more focus to that object.

Cropping reduces background noise and can help the model better understand what it should be learning.

## Convert to a Different Color Space

Sometimes, changing the color space—like converting from RGB to HSV—can make your object of interest stand out more. Experimenting with color space can highlight features that might otherwise get lost.

## Normalization

If your dataset includes images taken under very different lighting conditions, normalization can help. This process adjusts the brightness levels across images so that they are more consistent.

## Adjust Contrast

If the object of interest blends into the background, increase the contrast to separate it visually. This makes it easier for the model to detect edges and boundaries.

## Apply Filters

Use filters to enhance regions of interest in the image. For example:

* **High-pass filters** can enhance edges and fine details—useful when the object is defined by its outline.
* **Low-pass filters** can smooth out noise and highlight broader shapes—helpful in cluttered scenes.


# Home
Source: https://landinglens.docs.landing.ai/index



<div>
  # Develop computer vision models with&#x20;

  <div>
    Learn how to get started with .
  </div>

  <div>
    <CardGroup>
      <Card title="LandingLens" icon="file-import" href="https://app.landing.ai/">
        Create an account or log in to LandingLens.
      </Card>

      <Card title="Start Here" icon="play" href="/landinglens-workflow">
        Learn about the basic  workflow.
      </Card>
    </CardGroup>

    <CardGroup>
      <Card title="API Reference" icon="code" href="/api-reference/image/get-project-metadata">
        Integrate and scale using our API.
      </Card>

      <Card title="What's New" icon="star" href="/landinglens-release-notes">
        Learn about changes and new features in .
      </Card>
    </CardGroup>
  </div>
</div>

<div>
  # Deployment Options

  <div>
    Learn about the different methods for deploying  computer vision models.
  </div>

  <div>
    <CardGroup>
      <Card title="Cloud Deployment" icon="cloud" href="/cloud-deployment">
        Deploy to an endpoint hosted within the LandingLens app.
      </Card>

      <Card title="LandingEdge" icon="industry" href="/landingedge/landingedge-overview">
        Deploy to the LandingEdge app and communicate with edge devices, industrial cameras, and PLCs.
      </Card>

      <Card title="Docker" icon="docker" href="/landingedge/docker-deploy">
        Deploy the model and run inference in a self-hosted Dockerized container.
      </Card>
    </CardGroup>
  </div>

  <div>
    # Scale with Our Libraries

    <div>
      Use our Python and JavaScript libraries to acquire images and run inference programmatically.
    </div>

    <div>
      <CardGroup>
        <Card title="Python Library" icon="python" href="https://github.com/landing-ai/landingai-python" />

        <Card title="JavaScript Library" icon="js" href="https://github.com/landing-ai/landingai-js" />
      </CardGroup>
    </div>
  </div>
</div>


# Install and Upgrade LandingLens on Snowflake
Source: https://landinglens.docs.landing.ai/install-landinglens-in-snowflake



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✖</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

## Installation Requirements

* Before installing any apps from the Snowflake Marketplace, a user with the ORGADMIN role must accept the Consumer Terms of Service for the Snowflake Marketplace. For more details, go to the [Snowflake Documentation](https://other-docs.snowflake.com/en/collaboration/consumer-becoming#accept-the-snowflake-provider-and-consumer-terms-of-service).
* To install an app, you must use the ACCOUNTADMIN role or another role with the IMPORT SHARE and CREATE privileges. For more details, go to the [Snowflake Documentation](https://other-docs.snowflake.com/en/native-apps/consumer-installing).
* You must have a warehouse to run the LandingLens installer. The warehouse can be any size (including X-Small) and can have auto-suspend enabled.
* LandingLens is not available on Snowflake trial accounts.

## Request the LandingLens App

Access to the LandingLens app is available by request. To request the app, follow the instructions below:

1. Open the [LandingAI](https://app.snowflake.com/marketplace/providers/GZTYZF0O17X/LandingAI) provider page in the Snowflake Marketplace.
2. Locate and click the **LandingLens - Visual AI Platform** listing.
3. Click **Request**.
   <img alt="LLSF_VisualAI_Request" />
4. Fill out and submit the request form.
5. The LandingAI team will review the request and contact you with more information.

## Install the LandingLens App

After you've [requested the app](./install-landinglens-in-snowflake#request-the-landinglens-app) and been granted access it, follow the instructions below to install it in Snowflake:

1. Open the [LandingAI](https://app.snowflake.com/marketplace/providers/GZTYZF0O17X/LandingAI) provider page in the Snowflake Marketplace.
2. Locate and click the **LandingLens - Visual AI Platform** listing.
3. Click **Get**.
   <img alt="LL_VisualAIPlatform(1)" />
4. Select the **Warehouse** to use for the installation process. The warehouse can be any size (including X-Small) and can have auto-suspend enabled.
5. If you want to change the name of the application, click **Options** and enter a name in **Application Name**.
6. Click **Get**.
   <img alt="LLSF_install_1_11_2024" />
7. Go to **Snowsight** > **Data Products** > **Apps**. Click the LandingLens app listing. (Although the app is listed in the Installed Apps section, it is not installed yet.)
   <img alt="LLSF_update_1" />
8. A new page opens. It has a series of steps that guide you through the installation process.
9. In **Step 1**, click **Grant**. These permissions allow LandingLens to create compute pools and perform other tasks in your account.
   <img alt="LLSF_install_3_11_2024" />
10. In **Step 2**, click **Review**. Review the allowed endpoints on the pop-up and click **Connect**. This allows LandingLens to access the Internet.
    <img alt="LLSF_install_4_internet" />
11. Scroll to the top of the page and click **Activate**.
    <img alt="LLSF_install_5_11_2024(2)" />
12. LandingLens opens in your Apps. Click **Launch App**.
    <img alt="LLSF_install_7_11_2024" />
13. The installer opens in the **APP\_WIZARD** tab.
14. Click **Install**. The installer installs all the required services for the LandingLens app. This process takes about 20 to 30 minutes. Do NOT close the tab until the upgrade process is complete.
    <img alt="LLSF_install_8_11_2024" />
15. Once the upgrade process is complete, all services will have a green checkmark, and this message will display:"Installation Completed"
    <img alt="LLSF_update_5(1)" />

## Log In to the LandingLens App on Snowflake

After you install LandingLens, the URL to access your instance of LandingLens displays. Copy and paste the URL into a new tab to open the LandingLens app. We recommend bookmarking this URL.

Only users with the correct privileges in the account can access the LandingLens app.

<img alt="LLSF_URL" />

## Upgrade LandingLens on Snowflake

Users with the ACCOUNTADMIN role can upgrade LandingLens when a new version is available.

### Check if a New Version of LandingLens Is Available (In the App)

When a new version of LandingLens is available, a button displays in the top right corner of the app with this text:

> Upgrade to \[current\_version].

Click the button to launch the app installer in Snowsight.

<img alt="upgrade_app_v1_2_42" />

### Check if a New Version of LandingLens Is Available (In Snowsight)

To check if there's a new version of LandingLens available in Snowsight:

1. Open [Snowsight](https://app.snowflake.com).
2. Go to **Data Products** > **Apps**. Click the LandingLens app listing.
   <img alt="LLSF_update_1" />
3. Click **Launch App**.
   <img alt="LLSF_update_2(1)" />
4. The **APP\_WIZARD** tab opens. If a new version of LandingLens is available, this message displays:

> The app is out of date. Please use the installer to upgrade from \[installed version] to \[current\_version].

<img alt="LLSF_update_3" />

### Before You Upgrade

Be aware of this information before you start the upgrade:

* The upgrade process takes about 20 to 30 minutes.
* The upgrade process will interrupt any active training jobs. Ensure that all training is completed before you start the upgrade.
* Users will not be able to access LandingLens during the upgrade.

### Upgrade the App

To update :

1. If you're in the LandingLens app and a new version is available, click the **Upgrade** button that displays in the top right corner to launch the installer and go to step 6. Otherwise, go to step 2.
   <img alt="upgrade_app_v1_2_42" />
2. Open [Snowsight](https://app.snowflake.com).
3. Go to **Data Products** > **Apps**. Click the LandingLens app listing.
   <img alt="LLSF_update_1" />
4. Click **Launch App**.
   <img alt="LLSF_update_2(1)" />
5. The **APP\_WIZARD** tab opens.
6. Click **Upgrade**. The installer updates all the required services for the LandingLens app. This process takes about 20 to 30 minutes. Do NOT close the tab until the upgrade process is complete.
   <img alt="LLSF_update_4" />
7. Once the upgrade process is complete, all services will have a green checkmark, and this message will display:"Installation Completed"
   <img alt="LLSF_update_5(1)" />

## LandingLens Warehouse

During the installation process, LandingLens creates an X-Small warehouse called LANDINGLENS\_NATIVE\_APP. The LandingLens app uses this warehouse to run database queries.

## Troubleshooting Tips

### Errors During the Installation or Upgrade Process

During the installation or upgrade process, you might get errors, such as `Number of retries exceeded`. Or, some of the services might still have the status MISSING (yellow triangle).

To resolve these issues, click **Upgrade** or **Resume**. This triggers the installer to attempt to install the service again.

### Error: Initializing the Configuration Flow

During the installation process, you might get this error:

> There was an error initializing the configuration flow. Close the dialog and try again.

If you get this error message, try selecting a different warehouse from the drop-down menu in the top right corner.


# January 2022 Release Notes
Source: https://landinglens.docs.landing.ai/january-2022-release-notes



## Data Browser Updates

To make managing your media even easier, we've implemented two fundamental changes to how we label and split images:

### Direct Image Labeling

When viewing viewing a single image you will see a new UI element at the top left. By default you will be in "View" mode but if you switch to "Label", you can add GT labels directly to each image.

This method will speed up your labeling but be warned, without a reviewer or agreement labeling, there is an increased chance of mislabeled images going unnoticed.

### Splits

We've moved split out of the Metadata section and made it an independent element. You can now adjust split directly in the image view. To Auto Split, from the data browser simply select the three vertical dots next to "Split" and then choose "Auto Split".

## Classification Activation Heatmap

To help with classification error analysis, we've implemented a heatmap "visual explanation" for all classification models. Now when conducting error analysis, users' can see the specific area of each image that caused it to be classified in a specific way.

Here we can see the heatmap highlights the cracked portion of the cement square - this was the area of the image that caused the model to classify this example as "cracked".

You can learn more about the approach [here](https://arxiv.org/abs/1610.02391).

## Training Hour Usage

You can now see your organizations per project GPU training usage by hours. To see how many hours you've spent training models during a month, choose **Projects** > **View Projects**. You'll see the GPU hrs for the current and previous month listed next to each project.

## Pause Cloud Instances

From the device media page you can now pause cloud instances used for deployment. Simply navigate to Devices and choose the vertical three dots under actions on the right of the page.


# JSON Responses
Source: https://landinglens.docs.landing.ai/json-responses



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span> (see exceptions below)</td>
    </tr>
  </tbody>
</table>

When you run inference on images, the prediction results display in a JSON format. The JSON schema varies based on model type. This article describes the JSON responses for each model type, and provides example code snippets and images.

## Differences Between Cloud Deployment, LandingEdge, and Docker

The JSON schema is slightly different between inferences run via Cloud Deployment, and inferences run via LandingEdge and Docker. For example, some elements display in a different order, and the [predictions](./json-responses#postprocessing-and-backbone-elements) are included in different elements. Differences between the schemas are noted in the tables.

Example responses are from Cloud Deployments.

### Post-Processing and "Backbone" Elements

When an image is sent for inference via Cloud Deployment, it goes through the model, and then through a post-processing Classification step. This step classifies the image as `"OK"` or `"NG"` (short for "Not Good"). Because the process has two steps, the JSON schema for Cloud Deployment includes two sets of predictions:

* `backbonetype` and `backbonepredictions`: These elements contain the data for the actual model that ran inference on the image.
* `type` and `predictions`: These elements contain the data for the Classification step.

By default, LandingEdge and Docker don't have the post-processing Classification step. The JSON schema for these methods contains the prediction information in the `type` and `predictions` elements.

However, you can [run a script](./landingedge/custom-processing) that adds a post-processing model or Classification step when running inference with LandingEdge or Docker. If a post-processing step is added, the JSON will have the same prediction elements that are used for Cloud Deployments. In other words, the model predictions will move to the `backbonetype` and `backbonepredictions` elements, and the predictions for the post-processing step will be in the `type` and `predictions` elements.

## JSON Responses for Object Detection Models

The following table describes the objects in the JSON response for Object Detection models. An example response is [here](./json-responses#example-object-detection-json-response).

| Element                                                                           | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| --------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `backbonetype` (Cloud Deployment)<br />`type` (LandingEdge, Docker)               | The name of the prediction type. For Object Detection, this will always be `ObjectDetectionPrediction`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| `backbonepredictions` (Cloud Deployment)<br />`predictions` (LandingEdge, Docker) | This object contains the information for each region that the model predicted as an object of interest. Each prediction is a separate object nested in this element.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| `xxxxxxxxxxxxx-xxxx-xxxx-xxxxxxxxxxxx`                                            | This alphanumeric number is an internal identifier for the region that the model predicted as an object of interest.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| `score`                                                                           | The confidence score for the prediction.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| `labelName`                                                                       | The predicted class.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| `labelIndex`                                                                      | The internal identifier of the predicted class. Each class in a project is assigned a number, starting with 0. If you delete a class, that class’s number is not re-assigned to any current or future classes in that project.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| `coordinates`                                                                     | The x and y coordinates (in pixels) of the edges of the bounding box around the predicted object of interest.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `defect_id`                                                                       | The unique identifier for the predicted class.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| `predictions` (Cloud Deployment)                                                  | When an image is sent for inference via Cloud Deployment, it goes through the model, and then through a post-processing Classification step. The `predictions` object contains the results from the Classification step. This step classifies the image as `"OK"` or `"NG"` (short for "Not Good").<br /><br />This step simplifies defect detection. For example, if a model checks sheet metal for scratches, the metal should be marked as defective regardless if there are one or many scratches.<br /><br />`score`: Confidence score for the Classification prediction.<br />`labelName`: If the number of predictions is > 0 then `"NG"`, else `"OK"`.<br /><br />This element is only applicable to Cloud Deployment. Inference run via LandingEdge and Docker does not include the post-processing Classification step. |
| `"type": "ClassificationPrediction"` (Cloud Deployment)                           | When an image is sent for inference via Cloud Deployment, it goes through the model, and then through a post-processing Classification step. This object is the prediction type of the post-processing Classification step.<br /><br />This element is only applicable to Cloud Deployment. Inference run via LandingEdge and Docker does not include the post-processing Classification step.                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| `metadata` (LandingEdge, Docker)                                                  | This element contains nested metadata from the image. If the [Image Source](./landingedge/manage-inspection-points#image-source) is **Folder Watcher**, some data is populated by default. You can use [scripts](./landingedge/custom-processing#add-metadata-to-images) and web APIs to set or override the values.<br /><br />This element only displays in the JSON response for LandingEdge and Docker.                                                                                                                                                                                                                                                                                                                                                                                                                       |
| `image_id` (LandingEdge, Docker)                                                  | If the [Image Source](./landingedge/manage-inspection-points#image-source) is **Folder Watcher**, this is the file name of the image. Otherwise, this object is blank. You can use [scripts](./landingedge/custom-processing#add-metadata-to-images) and web APIs to set or override the values.<br /><br />This element only displays in the JSON response for LandingEdge and Docker.                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| `inspection_station_id` (LandingEdge, Docker)                                     | This element is blank by default. You can use [scripts](./landingedge/custom-processing#add-metadata-to-images) and web APIs to set or override the values.<br /><br />This element only displays in the JSON response for LandingEdge and Docker.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| `location_id` (LandingEdge, Docker)                                               | If the [Image Source](./landingedge/manage-inspection-points#image-source) is **Folder Watcher**, this is the directory that the image is in. Otherwise, this object is blank. You can use [scripts](./landingedge/custom-processing#add-metadata-to-images) and web APIs to set or override the values.<br /><br />This element only displays in the JSON response for LandingEdge and Docker.                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| `capture_timestamp` (LandingEdge, Docker)                                         | The time and date that OCR was run on the image. You can use [scripts](./landingedge/custom-processing#add-metadata-to-images) and web APIs to set or override the values.<br /><br />This element only displays in the JSON response for LandingEdge and Docker.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| `latency`                                                                         | The `latency` object includes the detailed timing statistics of the inference call.Each key-value pair in the `latency` object represents a step in the inference process, and the duration of that step. All values are measured in seconds.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `model_id`                                                                        | The unique identifier for the deployed model, which is specific to the model and its threshold. This is the value that **Copy Model ID** copies from the **Actions** menu on the [Models page](./models-page).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |

### Coordinates in Object Detection Responses

The JSON response for Object Detection predictions includes a `coordinates` object, which communicates the size and location of the bounding box around the prediction region of interest.

Each section includes the coordinates of the pixels for each edge of the bounding box. The origin for the coordinates is the top left corner of the image.

For example, let's say that the following snippet is the `coordinate` object in the JSON output for a prediction.

```json theme={null}
"coordinates": {
   "xmin": 3627,
   "ymin": 979,
   "xmax": 3965,
   "ymax": 1299
},
```

The coordinates correspond to the points described in the following table and image.

| **Name** | **Description**                                                                         | **Coordinate (in pixels)** |                                                |
| -------- | --------------------------------------------------------------------------------------- | -------------------------- | ---------------------------------------------- |
| xmin     | The distance from the left edge of the image to the **left side** of the bounding box.  | 3627                       |                                                |
| ymin     | The distance from the top of the image to the **top side** of the bounding box.         | 979                        |                                                |
| xmax     | The distance from the left edge of the image to the **right side** of the bounding box. | 3965                       |                                                |
| ymax     | The distance from the top of the image to the **bottom side** of the bounding box.      | 1299                       | <img alt="ObjectDetection_Coordinates_2024" /> |

### Example: Object Detection JSON Response

The following code snippet and image show the predictions for an Object Detection model trained to detect hard hats. The model has one class: Hard Hat. The model correctly predicted two hard hats. Each prediction is nested in the `backbonepredictions` object.

This JSON response is from Cloud Deployment.

```json theme={null}
{
    "backbonetype": "ObjectDetectionPrediction",
    "backbonepredictions": {
        "4eb97aa5-f2ce-4070-ab46-b2963cb8760f": {
            "score": 0.809603214263916,
            "labelName": "Hard Hat",
            "labelIndex": 1,
            "coordinates": {
                "xmin": 1487,
                "ymin": 1813,
                "xmax": 2103,
                "ymax": 2199
            },
            "defect_id": 152450
        },
        "ae80073f-4f30-48ca-9049-cd227ad210b1": {
            "score": 0.7299894094467163,
            "labelName": "Hard Hat",
            "labelIndex": 1,
            "coordinates": {
                "xmin": 6373,
                "ymin": 1866,
                "xmax": 6955,
                "ymax": 2195
            },
            "defect_id": 152450
        }
    },
    "predictions": {
        "score": 0.809603214263916,
        "labelName": "NG",
        "labelIndex": 1
    },
    "type": "ClassificationPrediction",
    "latency": {
        "preprocess_s": 0.4117429256439209,
        "infer_s": 0.329150915145874,
        "postprocess_s": 0.0005364418029785156,
        "serialize_s": 0.00045990943908691406,
        "input_conversion_s": 0.639418363571167,
        "model_loading_s": 5.3452112674713135
    },
    "model_id": "832050ab-dd69-46a2-84a9-5a811f2e8188"
}
```

<img alt="JSON_ObjectDetection_HardHat" />

## JSON Responses for Segmentation and Visual Prompting Models

<Info> is not available in .</Info>
The following table describes the objects in the JSON response for Segmentation and Visual Prompting models. See these [Segmentation](./json-responses#example-segmentation-json-response) and [Visual Prompting](./json-responses#example-visual-prompting-json-response) examples.

| Element                                                                           | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| --------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `backbonetype` (Cloud Deployment)<br />`type` (LandingEdge, Docker)               | The name of the prediction type. For Segmentation, this will always be `SegmentationPrediction`. For Visual Prompting, this will always be `null`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| `backbonepredictions` (Cloud Deployment)<br />`predictions` (LandingEdge, Docker) | For Segmentation, this object contains information about the image and the model's predictions. For Visual Prompting, this will always be `null`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| `imageHeight`                                                                     | The height of the image in pixels.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| `imageWidth`                                                                      | The width of the image in pixels.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| `encoding`                                                                        | The information about how LandingLens encodes Segmentation predictions. Predictions are encoded with run-length encoding (RLE). 0 is mapped to Z, and 1 is mapped to N. This section will always be: "encoding": `{ "algorithm": "rle", "options": { "map": { "Z": 0, "N": 1 } } }`,                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `bitmaps`                                                                         | This object contains the information for each class that the model predicted in the image. Each predicted class is a separate object nested in the `bitmaps` object.<br /><br />LandingEdge includes data for all classes in the project, and not just the ones predicted in the image.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| `xxxxxxxxxxxxx-xxxx-xxxx-xxxxxxxxxxxx`                                            | This alphanumeric number is an internal identifier for the region that the model predicted as an object of interest. The prediction information is nested in this object.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| `score`                                                                           | The confidence score for the prediction.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| `bitmap`                                                                          | The prediction mask (the areas that the model predicted for a specific class) is formatted as a bitmap that is compressed with a run-length encoding (RLE) format.<br /><br />The  [Python library](https://github.com/landing-ai/landingai-python) parses the JSON responses, which includes parsing and extracting bitmaps. We recommend using the library if you want to avoid manually parsing the bitmaps.<br /><br />Check out the [Satellite Images and Post-Processing](https://github.com/landing-ai/landingai-python/blob/main/examples/post-processings/farmland-coverage/farmland-coverage.ipynb) tutorial for an end-to-end example of running inference and visualizing the results with our Python library.<br /><br />You can use the [decode\_bitmap\_rle](https://landing-ai.github.io/landingai-python/api/common/#landingai.common.decode_bitmap_rle) API to decode the bitmap string into a NumPy array, which you can then convert into a PNG file. |
| `defect_id`                                                                       | The unique identifier for the predicted class.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| `labelIndex`                                                                      | The internal identifier of the predicted class. Each class in a project is assigned a number, starting with 0. If you delete a class, that class’s number is not re-assigned to any current or future classes in that project.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| `labelName`                                                                       | The predicted class.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `data` (Cloud Deployment)                                                         | This will always be `null`.<br /><br />This element only displays in the JSON response for Cloud Deployment.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| `labels` (Cloud Deployment)                                                       | This will always be `null`.<br /><br />This element only displays in the JSON response for Cloud Deployment.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| `num_classes` (Cloud Deployment)                                                  | This is the total number of classes in the project. Segmentation and Visual Prompting projects have an internal class called `“ok”`. This class is included in the `num_class` object. So if you created 3 classes in the project, the `num_class` value is 4.<br /><br />This element only displays in the JSON response for Cloud Deployment.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| `predictions` (Cloud Deployment)                                                  | When an image is sent for inference via Segmentation or Visual Prompting, it goes through the model, and then through a post-processing Classification step. The `predictions` object contains the results from the Classification step. This step classifies the image as `"OK"` or `"NG"` (short for "Not Good").<br /><br />This step simplifies defect detection. For example, if a model checks sheet metal for scratches, the metal should be marked as defective regardless if there are one or many scratches.<br /><br />`score`: Confidence score for the Classification prediction.<br />`labelName`: If the number of predictions is > 0 then `"NG"`, else `"OK"`.<br /><br />This element is only applicable to Cloud Deployment. Inference run via LandingEdge and Docker does not include the post-processing Classification step.                                                                                                                         |
| `"type": "ClassificationPrediction"` (Cloud Deployment)                           | When an image is sent for inference via Cloud Deployment, it goes through the model, and then through a post-processing Classification step. This object is the prediction type of the post-processing Classification step.<br /><br />This element is only applicable to Cloud Deployment. Inference run via LandingEdge and Docker does not include the post-processing Classification step.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| `metadata` (LandingEdge, Docker)                                                  | This element contains nested metadata from the image. If the [Image Source](./landingedge/manage-inspection-points#image-source) is **Folder Watcher**, some data is populated by default. You can use [scripts](./landingedge/custom-processing#add-metadata-to-images) and web APIs to set or override the values.<br /><br />This element only displays in the JSON response for LandingEdge and Docker.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| `image_id` (LandingEdge, Docker)                                                  | If the [Image Source](./landingedge/manage-inspection-points#image-source) is **Folder Watcher**, this is the file name of the image. Otherwise, this object is blank. You can use [scripts](./landingedge/custom-processing#add-metadata-to-images) and web APIs to set or override the values.<br /><br />This element only displays in the JSON response for LandingEdge and Docker.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| `inspection_station_id` (LandingEdge, Docker)                                     | This element is blank by default. You can use [scripts](./landingedge/custom-processing#add-metadata-to-images) and web APIs to set or override the values.<br /><br />This element only displays in the JSON response for LandingEdge and Docker.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| `location_id` (LandingEdge, Docker)                                               | If the [Image Source](./landingedge/manage-inspection-points#image-source) is **Folder Watcher**, this is the directory that the image is in. Otherwise, this object is blank. You can use [scripts](./landingedge/custom-processing#add-metadata-to-images) and web APIs to set or override the values.<br /><br />This element only displays in the JSON response for LandingEdge and Docker.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| `capture_timestamp` (LandingEdge, Docker)                                         | The time and date that OCR was run on the image. You can use [scripts](./landingedge/custom-processing#add-metadata-to-images) and web APIs to set or override the values.<br /><br />This element only displays in the JSON response for LandingEdge and Docker.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| `latency`                                                                         | The `latency` object includes the detailed timing statistics of the inference call.Each key-value pair in the `latency` object represents a step in the inference process, and the duration of that step. All values are measured in seconds.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| `model_id`                                                                        | The unique identifier for the deployed model, which is specific to the model and its threshold. This is the value that **Copy Model ID** copies from the **Actions** menu on the [Models page](./models-page).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |

### Example: Segmentation JSON Response

The following code snippet and image show the predictions for a Segmentation model trained to detect chips on pills. The model has one class: Chipped. Even though there is more than one chipped region, all of the data for Chipped predictions are included in one `bitmap` object, because these regions all correspond to the Chipped class.

This JSON response is from Cloud Deployment.

In the image, the purple overlay is the prediction for Chipped.

```json theme={null}
{
    "backbonetype": "SegmentationPrediction",
    "backbonepredictions": {
        "imageHeight": 1024,
        "imageWidth": 1024,
        "encoding": {
            "algorithm": "rle",
            "options": {
                "map": {
                    "Z": 0,
                    "N": 1
                }
            }
        },
        "bitmaps": {
            "8276bc82-d378-3ea0-ca4e-51c0549f73db": {
                "score": 0.969035930985445,
                "bitmap": "315776Z2N23Z13N984Z8N16Z21N978Z10N14Z23N977Z10N14Z23N975Z12N13Z25N973Z14N9Z30N954Z8N7Z16N7Z34N949Z35N3Z40N2Z2N942Z35N3Z40N2Z2N938Z88N934Z91N931Z100N923Z102N922Z102N922Z103N918Z108N912Z112N912Z112N908Z117N905Z119N902Z123N901Z124N900Z124N899Z127N897Z128N895Z130N894Z130N892Z134N890Z135N888Z136N887Z138N886Z138N885Z139N885Z139N883Z142N882Z142N881Z143N881Z143N880Z144N880Z144N880Z144N878Z146N878Z146N877Z146N878Z146N878Z146N877Z147N877Z147N877Z147N877Z147N877Z146N878Z146N878Z146N878Z146N878Z146N877Z147N877Z147N877Z146N878Z146N878Z146N878Z146N879Z145N880Z142N882Z142N882Z142N883Z141N885Z139N885Z139N885Z139N886Z138N886Z138N886Z138N886Z138N886Z140N884Z140N884Z141N883Z141N883Z141N884Z140N884Z141N885Z139N885Z139N885Z140N884Z140N885Z141N883Z141N883Z141N883Z141N883Z139N885Z138N886Z138N886Z137N887Z134N891Z126N898Z119N905Z119N905Z117N907Z117N907Z117N907Z117N907Z117N908Z116N908Z116N910Z114N910Z114N910Z114N910Z114N911Z113N911Z113N911Z113N912Z112N912Z110N916Z108N916Z108N916Z108N916Z108N917Z107N917Z107N917Z107N917Z107N917Z107N917Z107N917Z107N917Z107N916Z110N914Z110N912Z112N912Z112N911Z113N911Z114N909Z116N908Z116N906Z119N905Z121N902Z122N902Z123N901Z123N901Z123N900Z124N900Z125N899Z125N899Z125N899Z125N899Z127N898Z126N898Z126N898Z126N898Z127N897Z127N11Z4N882Z127N10Z4N883Z127N10Z4N883Z127N10Z3N883Z128N8Z5N883Z128N6Z7N883Z128N6Z7N883Z141N883Z139N884Z140N884Z140N884Z140N885Z136N888Z107N9Z16N892Z104N920Z104N920Z101N924Z96N928Z90N934Z80N944Z80N944Z76N948Z76N948Z76N5Z4N938Z78N1Z10N935Z78N1Z10N935Z91N130Z3N800Z89N132Z4N798Z90N132Z5N797Z90N132Z5N797Z90N132Z7N795Z89N132Z8N795Z88N133Z9N794Z88N132Z10N794Z88N132Z10N794Z87N131Z12N794Z84N134Z12N794Z83N134Z13N794Z83N134Z13N795Z55N4Z22N134Z14N795Z51N10Z17N136Z15N795Z47N16Z14N137Z15N796Z45N18Z10N113Z9N7Z7N4Z15N796Z45N18Z10N113Z9N7Z7N4Z15N796Z45N20Z4N114Z26N2Z16N797Z44N138Z28N1Z16N797Z42N139Z29N1Z16N797Z42N139Z29N1Z16N797Z41N140Z46N797Z40N139Z46N799Z37N132Z56N799Z36N132Z57N799Z36N132Z57N800Z34N133Z57N802Z30N134Z58N803Z27N136Z58N806Z21N139Z57N807Z21N139Z57N808Z16N141Z59N810Z12N143Z59N812Z9N144Z59N812Z9N144Z59N813Z5N147Z59N814Z3N147Z61N962Z62N960Z66N958Z66N957Z68N8Z7N935Z93N929Z98N5Z8N913Z98N5Z8N913Z112N912Z113N910Z114N910Z115N909Z115N908Z118N906Z119N904Z123N14Z5N882Z123N14Z5N882Z126N9Z9N878Z131N5Z12N875Z134N3Z13N873Z152N872Z152N871Z154N868Z156N867Z157N866Z158N866Z158N863Z163N860Z164N859Z165N859Z165N859Z166N856Z169N855Z174N850Z177N847Z177N847Z179N844Z182N842Z183N841Z183N840Z184N838Z186N838Z187N835Z189N835Z189N830Z194N814Z7N7Z198N811Z9N5Z199N811Z9N5Z199N810Z11N4Z199N809Z14N2Z200N808Z14N2Z202N806Z221N803Z221N803Z222N802Z221N803Z218N807Z214N810Z214N810Z211N813Z211N812Z213N811Z213N805Z219N803Z221N799Z227N794Z230N794Z230N791Z233N786Z12N7Z219N783Z14N8Z219N783Z14N8Z219N783Z17N5Z219N783Z19N1Z221N782Z242N782Z242N782Z242N782Z242N783Z241N783Z241N783Z241N769Z255N769Z255N769Z255N769Z256N768Z256N768Z256N768Z256N767Z258N766Z258N766Z258N766Z258N766Z258N766Z258N766Z258N766Z258N764Z260N764Z260N763Z261N763Z261N763Z260N755Z1N7Z261N763Z261N763Z261N763Z260N762Z262N762Z260N763Z260N764Z260N763Z260N764Z258N766Z258N766Z258N765Z259N763Z261N763Z261N763Z260N764Z260N763Z261N763Z261N763Z261N763Z261N763Z261N763Z260N764Z260N765Z259N765Z259N765Z258N766Z258N768Z256N769Z253N771Z253N771Z253N770Z253N771Z253N771Z253N769Z255N769Z255N769Z254N770Z254N770Z254N772Z252N772Z252N772Z251N773Z251N773Z251N773Z251N773Z249N776Z247N777Z247N777Z246N778Z244N781Z242N782Z240N784Z240N784Z237N787Z236N789Z233N791Z233N791Z231N793Z230N794Z228N798Z224N800Z224N800Z222N803Z219N806Z217N807Z217N809Z213N812Z105N2Z103N815Z99N9Z98N818Z95N15Z95N819Z95N15Z95N820Z93N18Z93N822Z89N21Z91N824Z88N21Z91N824Z88N21Z91N825Z86N23Z62N2Z24N829Z84N24Z61N2Z23N831Z82N27Z57N5Z21N832Z80N29Z56N6Z20N833Z80N29Z56N6Z20N834Z79N30Z55N8Z16N837Z77N31Z54N9Z16N837Z76N33Z53N10Z14N838Z63N4Z8N35Z50N13Z12N839Z63N4Z8N35Z50N13Z12N841Z60N50Z43N19Z9N843Z59N53Z11N2Z27N24Z4N844Z59N60Z1N12Z16N876Z59N60Z1N12Z16N877Z56N968Z22N6Z27N970Z18N16Z19N973Z15N19Z15N975Z15N19Z15N976Z11N23Z7N984Z9N26Z2N988Z8N1016Z8N1019Z5N1020Z4N1021Z2N309854Z",
                "defect_id": 62504,
                "label_index": 1,
                "label_name": "Chipped"
            }
        },
        "data": null,
        "labels": null,
        "num_classes": 2
    },
    "predictions": {
        "score": 0.9999961853027344,
        "labelName": "NG",
        "labelIndex": 1
    },
    "type": "ClassificationPrediction",
    "latency": {
        "preprocess_s": 0.003261089324951172,
        "infer_s": 2.586284875869751,
        "postprocess_s": 0.0012137889862060547,
        "serialize_s": 0.029936552047729492,
        "input_conversion_s": 0.034484148025512695,
        "model_loading_s": 7.019518852233887
    },
    "model_id": "d35f3269-ebe9-4f0a-8694-1f65c5ee7036"
}
```

<img alt="JSON_segmentation" />

### Example: Visual Prompting JSON Response

<Info> is not available in .</Info>
The following code snippet and image show the predictions for a Visual Prompting model trained to detect shipping containers in ports. The model has two classes: Shipping Containers and Other. Each class is a separate object nested in the `bitmaps` object.

This JSON response is from Cloud Deployment.

In the image, the purple overlay is the prediction for Shipping Containers, and the yellow overlay is the prediction for Other.

```json theme={null}
{
    "backbonetype": null,
    "backbonepredictions": null,
    "predictions": {
        "imageHeight": 563,
        "imageWidth": 1000,
        "encoding": {
            "algorithm": "rle",
            "options": {
                "map": {
                    "Z": 0,
                    "N": 1
                }
            }
        },
        "bitmaps": {
            "d7d654b7-01ac-e5c4-af5b-3a5d28c6cb20": {
                "score": 1.0,
                "bitmap": "229Z30N264Z32N365Z15N294Z30N264Z34N363Z15N294Z30N263Z35N363Z15N294Z30N260Z39N362Z15N294Z30N259Z41N360Z18N292Z30N260Z40N360Z18N292Z30N259Z41N360Z18N292Z30N259Z41N360Z18N292Z33N255Z45N6Z4N347Z19N292Z32N255Z43N8Z2N349Z19N294Z28N257Z37N15Z1N349Z18N298Z24N258Z35N17Z1N349Z18N268Z19N15Z19N259Z32N21Z2N348Z13N270Z21N16Z18N10Z5N1Z1N242Z32N21Z4N348Z8N270Z24N18Z16N6Z13N242Z29N22Z10N18Z2N324Z3N253Z12N6Z26N18Z16N5Z19N253Z2N2Z3N61Z1N574Z46N18Z17N4Z22N888Z50N19Z13N2Z32N66Z3N814Z50N20Z12N3Z35N61Z9N810Z48N22Z12N3Z36N59Z12N806Z49N20Z56N55Z15N805Z53N12Z62N52Z14N806Z130N49Z14N807Z131N48Z14N806Z135N44Z13N808Z136N41Z15N785Z2N20Z138N40Z14N784Z10N6Z148N41Z10N784Z165N46Z2N737Z10N37Z168N781Z17N32Z170N775Z28N23Z174N237Z1N533Z32N23Z172N172Z1N596Z38N20Z171N767Z47N13Z170N769Z49N12Z169N768Z53N9Z169N767Z57N6Z170N765Z59N6Z169N761Z65N6Z165N50Z1N710Z68N7Z162N52Z1N698Z81N13Z18N17Z51N9Z7N28Z22N55Z3N693Z84N18Z7N50Z21N48Z21N55Z3N691Z91N15Z1N59Z15N48Z20N750Z95N11Z2N62Z12N46Z19N748Z101N10Z2N65Z8N46Z18N737Z116N4Z6N115Z19N736Z130N78Z2N34Z19N734Z46N9Z80N73Z8N29Z20N733Z44N13Z81N71Z9N27Z17N728Z50N17Z83N68Z14N10Z25N733Z48N19Z85N65Z17N4Z22N740Z45N22Z87N63Z42N741Z40N25Z92N58Z43N742Z38N27Z94N56Z43N742Z34N31Z98N54Z40N743Z32N33Z100N2Z22N28Z40N743Z30N34Z128N25Z38N745Z27N36Z132N23Z34N748Z25N37Z135N25Z30N748Z20N40Z143N10Z9N6Z37N2Z10N723Z15N45Z45N2Z116N6Z50N721Z8N51Z45N4Z115N9Z51N775Z46N5Z114N11Z50N774Z45N9Z111N12Z49N774Z45N14Z106N14Z50N772Z43N15Z103N18Z50N775Z37N19Z15N3Z80N23Z49N779Z31N21Z12N6Z77N25Z50N784Z24N25Z5N12Z73N29Z50N783Z22N45Z71N30Z49N12Z6N768Z17N48Z69N31Z50N10Z12N769Z5N58Z62N36Z68N835Z59N40Z66N47Z12N777Z54N50Z59N40Z28N770Z52N57Z53N37Z33N770Z47N64Z49N36Z36N769Z44N67Z48N33Z40N768Z42N70Z47N31Z45N764Z36N81Z15N3Z25N28Z50N12Z5N28Z12N705Z35N87Z4N10Z24N27Z53N10Z6N25Z15N64Z8N632Z28N54Z8N48Z20N28Z55N7Z9N20Z20N45Z6N7Z20N625Z27N54Z10N47Z20N28Z56N4Z12N18Z22N14Z3N26Z35N625Z24N56Z11N48Z17N29Z75N15Z24N12Z3N23Z37N628Z17N60Z15N46Z15N30Z85N4Z26N10Z7N18Z39N631Z10N64Z17N11Z7N26Z14N30Z87N1Z29N8Z18N7Z38N705Z38N27Z4N38Z117N6Z62N708Z39N66Z119N6Z58N712Z40N65Z173N694Z12N16Z42N63Z164N701Z18N12Z43N62Z158N705Z25N7Z47N58Z155N707Z27N6Z49N56Z155N705Z29N6Z52N52Z156N704Z31N3Z54N51Z157N703Z89N50Z158N702Z91N47Z162N75Z10N27Z14N574Z91N47Z162N73Z14N24Z20N17Z19N531Z94N45Z163N71Z17N22Z63N525Z94N30Z1N14Z164N70Z19N18Z67N521Z95N16Z23N6Z164N71Z17N19Z70N515Z29N5Z65N14Z26N5Z164N72Z16N19Z71N508Z29N11Z65N12Z29N3Z163N74Z16N18Z72N504Z24N20Z64N10Z131N5Z61N56Z2N18Z15N18Z75N500Z24N21Z64N10Z78N15Z37N7Z59N57Z4N19Z12N17Z76N500Z22N23Z64N10Z75N21Z32N9Z64N51Z9N17Z9N18Z82N494Z21N24Z7N2Z53N12Z73N23Z15N9Z6N11Z69N46Z10N18Z6N17Z88N490Z16N29Z6N4Z51N14Z62N35Z8N31Z76N38Z11N38Z95N486Z11N34Z6N5Z50N14Z61N40Z1N33Z16N3Z60N36Z11N36Z98N485Z7N38Z5N7Z49N14Z60N75Z15N10Z55N35Z12N34Z100N35Z11N289Z3N147Z3N55Z46N15Z41N5Z13N73Z15N17Z52N33Z13N33Z36N4Z62N32Z17N261Z9N224Z44N15Z42N5Z13N72Z16N18Z51N33Z16N30Z36N4Z61N31Z20N260Z14N221Z39N16Z44N6Z12N71Z19N16Z51N33Z18N27Z37N3Z58N34Z26N255Z15N220Z38N17Z43N7Z13N69Z20N16Z51N33Z20N23Z39N3Z57N34Z30N252Z17N220Z33N19Z44N7Z13N69Z20N16Z51N31Z23N20Z42N2Z55N36Z32N250Z18N220Z29N22Z44N7Z13N67Z22N17Z49N32Z24N16Z97N41Z36N246Z18N221Z25N25Z44N7Z14N65Z23N17Z50N31Z28N10Z97N45Z35N245Z17N226Z16N29Z45N5Z22N58Z22N19Z51N28Z86N3Z50N51Z34N238Z17N227Z11N33Z46N4Z24N55Z23N19Z51N27Z87N4Z49N55Z35N233Z15N273Z75N32Z44N20Z51N23Z89N10Z46N61Z36N225Z15N273Z75N29Z46N21Z51N22Z88N15Z43N67Z32N223Z14N274Z76N26Z48N22Z50N20Z64N4Z19N21Z40N71Z29N222Z14N274Z76N24Z47N25Z57N13Z60N50Z37N77Z26N220Z14N275Z75N21Z48N27Z60N9Z60N51Z35N80Z25N220Z13N277Z75N17Z47N33Z11N12Z39N4Z57N58Z27N88Z25N217Z12N280Z73N17Z46N34Z10N13Z95N63Z26N90Z24N217Z10N284Z73N13Z47N35Z7N18Z45N6Z36N71Z22N92Z26N215Z9N288Z68N15Z45N37Z7N18Z45N6Z35N81Z11N93Z27N215Z7N296Z20N4Z36N16Z43N40Z7N18Z46N5Z34N185Z28N527Z7N10Z28N22Z39N44Z8N17Z48N2Z32N186Z29N529Z5N14Z21N26Z38N45Z8N17Z81N187Z29N530Z3N23Z8N30Z36N48Z8N17Z67N9Z2N189Z29N594Z36N49Z8N17Z66N201Z28N597Z33N50Z8N17Z67N40Z3N157Z26N609Z21N23Z9N21Z6N18Z71N35Z7N157Z21N616Z14N24Z15N16Z6N19Z71N33Z11N155Z19N428Z18N206Z21N14Z4N20Z71N31Z37N132Z11N433Z24N202Z21N15Z2N22Z70N31Z37N135Z6N432Z32N196Z25N10Z6N21Z69N30Z39N574Z30N196Z26N4Z20N12Z68N30Z41N573Z31N195Z52N12Z65N28Z45N573Z34N191Z55N12Z59N28Z50N572Z34N190Z55N16Z11N7Z36N27Z52N573Z39N183Z57N35Z31N27Z57N100Z3N427Z3N41Z36N184Z56N36Z29N26Z59N99Z5N476Z20N196Z55N39Z21N27Z63N90Z18N690Z52N42Z16N27Z65N87Z23N690Z52N43Z9N30Z66N84Z30N524Z4N168Z47N75Z70N81Z39N513Z8N169Z46N72Z72N81Z42N312Z5N192Z10N170Z41N72Z75N78Z48N307Z8N191Z11N172Z35N73Z77N76Z50N307Z10N189Z11N175Z29N74Z77N75Z54N20Z1N282Z6N5Z5N186Z13N272Z80N14Z9N48Z83N276Z10N3Z7N185Z14N270Z80N7Z19N45Z85N270Z31N179Z14N269Z80N7Z21N42Z88N269Z33N177Z14N267Z83N5Z22N42Z87N266Z4N15Z19N179Z8N269Z111N39Z55N13Z20N268Z3N6Z29N179Z7N270Z111N39Z54N15Z16N268Z6N5Z31N180Z3N271Z112N38Z54N17Z11N272Z5N5Z32N451Z117N33Z54N303Z5N5Z32N451Z115N33Z56N305Z34N456Z115N30Z58N307Z30N460Z114N30Z57N313Z21N464Z112N30Z57N21Z6N290Z18N465Z112N31Z55N23Z6N293Z10N470Z111N31Z55N23Z8N762Z120N27Z65N18Z7N760Z121N25Z72N15Z7N753Z127N23Z81N7Z9N686Z2N62Z130N21Z84N5Z10N688Z1N61Z129N21Z86N2Z12N688Z1N60Z129N21Z100N46Z4N35Z10N654Z128N23Z99N47Z6N32Z13N445Z7N97Z1N100Z128N24Z98N48Z12N24Z28N432Z10N94Z2N100Z127N23Z99N49Z14N21Z30N430Z12N88Z9N97Z124N25Z101N48Z20N8Z40N427Z15N83Z12N97Z121N28Z100N49Z70N423Z17N82Z13N97Z119N29Z101N47Z73N421Z19N81Z13N97Z114N30Z101N49Z75N421Z19N81Z13N97Z111N32Z101N49Z76N421Z18N82Z13N96Z109N30Z103N45Z84N420Z18N82Z13N96Z107N30Z104N44Z86N116Z7N298Z15N83Z10N100Z104N31Z105N42Z89N423Z12N81Z17N95Z103N30Z108N44Z87N424Z11N79Z19N93Z104N28Z110N45Z87N426Z9N75Z24N90Z105N26Z111N48Z86N428Z6N74Z16N6Z4N89Z105N26Z112N49Z84N430Z5N66Z20N13Z1N86Z108N26Z111N51Z83N432Z2N67Z13N2Z3N100Z110N25Z111N54Z81N501Z10N106Z112N25Z111N54Z80N501Z6N110Z111N25Z112N58Z75N503Z5N111Z111N24Z113N45Z7N8Z73N502Z5N112Z110N24Z112N33Z22N9Z69N504Z5N112Z109N25Z111N30Z26N10Z67N505Z3N89Z16N8Z107N25Z114N29Z31N3Z67N508Z3N87Z131N26Z114N29Z101N510Z2N85Z132N25Z116N27Z102N492Z6N99Z130N21Z120N28Z102N492Z11N95Z130N21Z120N28Z102N491Z14N93Z127N23Z118N29Z104N492Z19N88Z126N21Z120N30Z103N493Z22N81Z127N22Z120N30Z102N495Z24N79Z126N22Z120N30Z104N495Z24N77Z127N22Z120N31Z103N496Z24N76Z126N23Z119N31Z104N495Z25N77Z124N24Z118N33Z102N350Z9N136Z25N79Z121N24Z119N37Z99N346Z29N121Z25N79Z121N23Z120N40Z95N346Z43N108Z24N80Z119N24Z118N45Z93N316Z1N27Z51N102Z23N80Z117N25Z118N49Z90N317Z3N25Z53N100Z22N81Z116N25Z116N52Z88N319Z5N23Z55N100Z16N86Z113N26Z116N51Z87N322Z5N23Z56N99Z15N88Z110N28Z115N50Z87N325Z5N24Z55N99Z11N94Z105N27Z117N50Z86N327Z7N25Z53N98Z10N97Z99N30Z118N48Z88N327Z7N27Z53N98Z7N100Z92N34Z117N50Z88N327Z8N32Z49N205Z85N38Z117N51Z87N328Z8N34Z47N206Z83N37Z119N51Z85N330Z8N36Z45N208Z81N34Z120N53Z82N333Z8N36Z45N209Z79N32Z120N56Z80N334Z10N38Z42N213Z75N30Z117N63Z76N336Z10N39Z41N216Z72N28Z117N65Z75N336Z11N39Z41N219Z69N28Z114N68Z75N336Z11N34Z45N222Z2N10Z53N30Z113N69Z73N338Z11N29Z49N236Z51N30Z111N72Z73N338Z10N27Z49N243Z46N30Z110N72Z74N339Z10N27Z48N247Z42N31Z107N75Z74N339Z10N26Z48N251Z37N32Z106N76Z74N337Z12N27Z48N252Z35N31Z107N72Z78N338Z10N29Z48N252Z34N32Z107N70Z78N340Z7N31Z49N221Z9N25Z28N33Z107N70Z78N342Z3N35Z50N217Z13N27Z24N31Z109N71Z78N379Z51N105Z6N105Z21N33Z7N29Z114N71Z31N10Z35N382Z51N105Z7N104Z28N62Z113N72Z33N8Z34N383Z50N107Z4N106Z31N58Z114N72Z74N385Z47N218Z34N55Z112N76Z69N389Z46N219Z35N52Z114N76Z68N390Z25N5Z15N220Z36N50Z114N80Z61N394Z24N8Z12N220Z37N50Z113N83Z57N382Z4N10Z22N14Z3N78Z3N40Z1N59Z10N31Z43N46Z112N88Z51N383Z11N5Z22N93Z6N28Z17N49Z16N28Z48N42Z112N90Z50N381Z13N5Z22N92Z10N23Z23N42Z22N22Z56N37Z112N90Z50N350Z1N27Z18N2Z22N90Z15N21Z25N37Z30N11Z66N31Z112N92Z50N349Z2N25Z43N87Z20N19Z28N33Z110N30Z110N94Z49N325Z5N19Z3N23Z42N87Z28N10Z34N28Z90N5Z18N29Z110N96Z48N324Z6N19Z3N22Z28N100Z33N5Z55N4Z93N8Z16N29Z110N96Z48N325Z6N17Z4N20Z26N103Z191N10Z14N29Z111N96Z48N323Z8N14Z7N15Z30N103Z191N16Z3N33Z110N99Z45N325Z9N11Z9N14Z32N101Z192N53Z110N99Z44N325Z10N10Z10N12Z33N99Z195N52Z109N101Z43N326Z10N9Z10N13Z33N97Z195N54Z109N100Z44N325Z11N5Z6N21Z33N95Z195N56Z106N103Z41N328Z11N5Z2N27Z31N94Z195N57Z105N104Z41N328Z11N4Z2N28Z30N91Z197N58Z105N105Z40N329Z8N7Z1N29Z28N90Z199N59Z102N54Z15N39Z39N330Z7N6Z2N30Z27N90Z199N60Z101N48Z2N1Z20N38Z37N332Z6N37Z27N88Z197N66Z99N46Z41N26Z34N333Z5N38Z25N89Z194N70Z97N47Z46N24Z31N376Z25N88Z191N75Z95N46Z51N25Z24N380Z24N89Z188N78Z95N46Z53N25Z21N381Z23N91Z186N79Z94N45Z55N26Z19N385Z5N110Z176N85Z92N44Z59N26Z13N391Z2N113Z172N88Z91N45Z60N28Z7N513Z163N93Z89N48Z59N309Z12N228Z21N1Z140N93Z86N51Z59N306Z18N227Z17N3Z139N94Z85N52Z60N302Z23N228Z11N6Z139N58Z13N23Z81N58Z58N300Z28N226Z9N7Z138N56Z18N21Z80N59Z60N293Z45N222Z146N52Z25N18Z77N62Z62N288Z51N212Z152N50Z28N18Z76N63Z63N294Z10N1Z35N204Z156N42Z40N16Z74N63Z68N292Z9N3Z35N201Z157N38Z44N16Z71N66Z68N292Z8N4Z36N199Z157N36Z48N15Z70N67Z69N293Z7N1Z42N192Z159N35Z50N15Z66N70Z70N293Z52N188Z161N34Z51N15Z65N70Z71N293Z53N183Z161N36Z52N15Z65N70Z72N293Z55N180Z161N37Z52N15Z63N70Z74N293Z56N177Z160N39Z53N15Z62N70Z75N294Z55N177Z160N39Z53N13Z63N70Z76N298Z51N177Z159N41Z50N17Z61N69Z77N304Z45N176Z159N42Z48N19Z58N70Z78N309Z41N176Z156N45Z45N22Z57N70Z79N312Z37N88Z13N75Z154N50Z40N25Z56N69Z81N312Z37N86Z17N73Z152N53Z37N27Z55N68Z83N314Z35N83Z23N70Z151N54Z36N28Z55N67Z84N315Z34N81Z30N64Z150N56Z21N6Z5N30Z55N67Z83N319Z31N82Z35N58Z149N59Z15N47Z55N65Z85N322Z27N81Z42N51Z149N61Z7N54Z54N66Z86N325Z23N81Z44N49Z148N63Z6N55Z53N67Z85N344Z4N81Z47N43Z150N125Z45N75Z86N429Z56N33Z150N127Z43N76Z85N429Z60N27Z150N130Z41N79Z84N429Z62N21Z152N133Z39N80Z81N430Z64N20Z151N135Z38N81Z81N428Z67N18Z149N61Z1N78Z36N81Z78N430Z71N15Z149N140Z35N82Z78N427Z81N8Z146N143Z33N84Z75N429Z85N4Z145N145Z32N86Z73N429Z87N3Z143N147Z31N87Z72N427Z231N152Z27N93Z68N429Z230N153Z26N95Z67N428Z230N156Z24N57Z9N35Z60N429Z230N157Z22N56Z16N33Z56N430Z229N160Z20N53Z22N32Z53N431Z226N168Z11N56Z25N36Z45N432Z226N235Z26N39Z41N433Z223N49Z3N186Z26N44Z34N436Z222N239Z25N46Z30N439Z219N242Z22N53Z23N441Z216N245Z20N58Z20N442Z214N248Z16N61Z18N445Z57N13Z111N280Z12N68Z11N448Z57N13Z108N284Z10N71Z7N452Z61N7Z107N289Z4N533Z62N6Z106N828Z62N5Z103N831Z61N11Z94N835Z60N13Z88N842Z157N843Z157N846Z154N71Z22N756Z151N70Z24N757Z149N68Z27N715Z4N41Z145N66Z30N712Z11N36Z146N64Z31N704Z28N31Z145N60Z34N698Z35N35Z138N60Z34N692Z48N36Z131N58Z36N690Z50N36Z130N56Z39N688Z52N35Z130N45Z50N688Z56N34Z126N37Z62N683Z60N33Z125N36Z64N682Z64N34Z117N37Z70N678Z67N33Z115N37Z70N677Z71N34Z110N35Z76N673Z75N32Z108N36Z91N657Z77N33Z106N35Z99N641Z91N31Z99N38Z102N635Z99N29Z96N37Z105N629Z110N25Z86N43Z109N626Z115N22Z83N44Z110N623Z120N20Z82N45Z110N621Z125N17Z77N50Z108N620Z128N17Z75N50Z109N618Z133N17Z71N52Z108N617Z135N17Z71N51Z108N615Z141N14Z68N54Z106N614Z151N5Z69N55Z105N599Z9N5Z226N55Z106N591Z247N55Z107N590Z248N55Z106N589Z192N1Z55N53Z110N589Z247N50Z115N585Z248N46Z125N581Z246N47Z127N579Z246N46Z129N576Z208N10Z29N46Z132N574Z209N12Z25N47Z133N573Z211N15Z20N40Z141N572Z215N15Z15N40Z142N571Z218N17Z2N48Z144N570Z220N64Z146N569Z221N64Z145N562Z229N63Z145N558Z234N63Z142N560Z235N61Z142N562Z234N61Z141N563Z235N61Z140N564Z234N61Z107N14Z18N566Z234N61Z111N11Z14N569Z230N66Z113N12Z1N578Z229N67Z114N590Z226N71Z113N590Z225N72Z114N589Z224N75Z112N590Z221N79Z109N592Z219N81Z108N595Z214N86Z105N596Z211N89Z104N597Z210N90Z103N600Z205N94Z100N602Z203N55Z7N34Z97N608Z195N52Z18N37Z90N612Z190N52Z20N40Z85N618Z182N54Z34N33Z78N620Z180N54Z37N34Z75N620Z179N53Z42N32Z73N623Z172N57Z48N32Z65N590Z3N35Z167N59Z50N34Z62N586Z12N33Z159N61Z57N45Z45N588Z13N34Z156N61Z60N44Z42N589Z15N35Z153N58Z68N41Z40N590Z16N35Z150N59Z71N39Z40N590Z19N36Z145N59Z75N37Z38N591Z21N48Z130N54Z86N34Z33N594Z21N52Z81N4Z40N52Z90N34Z31N595Z23N55Z73N9Z29N59Z95N33Z27N597Z24N55Z72N10Z24N61Z98N34Z23N600Z24N56Z70N12Z21N62Z99N34Z21N601Z28N55Z67N15Z12N67Z104N32Z15N607Z26N56Z66N94Z104N34Z11N609Z27N20Z9N29Z63N94Z105N35Z4N615Z27N18Z11N28Z63N93Z106N36Z2N617Z26N20Z9N29Z62N90Z109N656Z27N20Z7N29Z62N89Z110N658Z25N21Z6N29Z62N88Z111N660Z24N22Z2N32Z60N85Z115N660Z25N30Z1N25Z59N84Z116N664Z24N26Z5N22Z59N83Z118N664Z25N24Z5N22Z59N81Z122N667Z29N15Z10N22Z54N78Z126N667Z30N14Z24N11Z50N76Z129N668Z28N14Z25N14Z46N75Z133N666Z29N11Z26N18Z42N73Z137N666Z29N5Z30N19Z41N71Z139N673Z56N22Z39N69Z141N675Z54N25Z36N69Z141N676Z40N2Z10N28Z34N68Z142N683Z32N46Z29N65Z146N685Z30N47Z27N64Z146N690Z36N39Z24N62Z148N67Z15N610Z37N38Z23N61Z148N67Z19N609Z36N41Z18N58Z150N68Z21N608Z37N41Z17N57Z150N68Z23N608Z37N42Z13N59Z149N69Z23N609Z46N102Z150N70Z23N610Z50N95Z150N72Z23N613Z55N84Z150N76Z22N614Z56N79Z151N79Z21N615Z60N72Z151N82Z20N617Z58N70Z153N84Z17N620Z56N70Z152N86Z14N628Z50N69Z151N89Z10N634Z47N68Z151N91Z8N635Z46N68Z147N99Z4N637Z45N68Z136N751Z44N67Z137N755Z37N70Z135N759Z35N70Z136N763Z27N70Z139N765Z25N69Z141N769Z21N65Z144N772Z19N65Z142N775Z18N65Z142N778Z15N65Z141N780Z14N65Z140N784Z11N65Z139N786Z10N65Z139N862Z136N865Z135N867Z132N870Z129N871Z129N874Z123N878Z121N880Z119N884Z115N887Z111N894Z105N898Z101N905Z91N923Z76N926Z71N933Z65N936Z63N940Z56N945Z54N853Z2N92Z15N3Z28N860Z2N93Z13N4Z27N860Z3N93Z12N6Z25N959Z8N9Z23N961Z6N11Z20N965Z2N16Z17N985Z14N988Z12N993Z5N997Z1N13069Z6N994Z9N990Z14N985Z13N987Z12N988Z8N992Z8N990Z9N991Z8N994Z5N996Z4N997Z1N19950Z4N41701Z",
                "defect_id": 152878,
                "label_index": 1,
                "label_name": "Shipping Containers"
            },
            "5d4cb53f-4a39-774f-b97c-d4a26d868853": {
                "score": 1.0,
                "bitmap": "229N30Z264N32Z365N15Z294N30Z264N34Z363N15Z294N30Z263N35Z363N15Z294N30Z260N39Z362N15Z294N30Z259N41Z360N18Z292N30Z260N40Z360N18Z292N30Z259N41Z360N18Z292N30Z259N41Z360N18Z292N33Z255N45Z6N4Z347N19Z292N32Z255N43Z8N2Z349N19Z294N28Z257N37Z15N1Z349N18Z298N24Z258N35Z17N1Z349N18Z268N19Z15N19Z259N32Z21N2Z348N13Z270N21Z16N18Z10N5Z1N1Z242N32Z21N4Z348N8Z270N24Z18N16Z6N13Z242N29Z22N10Z18N2Z324N3Z253N12Z6N26Z18N16Z5N19Z253N2Z2N3Z61N1Z574N46Z18N17Z4N22Z888N50Z19N13Z2N32Z66N3Z814N50Z20N12Z3N35Z61N9Z810N48Z22N12Z3N36Z59N12Z806N49Z20N56Z55N15Z805N53Z12N62Z52N14Z806N130Z49N14Z807N131Z48N14Z806N135Z44N13Z808N136Z41N15Z785N2Z20N138Z40N14Z784N10Z6N148Z41N10Z784N165Z46N2Z737N10Z37N168Z781N17Z32N170Z775N28Z23N174Z237N1Z533N32Z23N172Z172N1Z596N38Z20N171Z767N47Z13N170Z769N49Z12N169Z768N53Z9N169Z767N57Z6N170Z765N59Z6N169Z761N65Z6N165Z50N1Z710N68Z7N162Z52N1Z698N81Z13N18Z17N51Z9N7Z28N22Z55N3Z693N84Z18N7Z50N21Z48N21Z55N3Z691N91Z15N1Z59N15Z48N20Z750N95Z11N2Z62N12Z46N19Z748N101Z10N2Z65N8Z46N18Z737N116Z4N6Z115N19Z736N130Z78N2Z34N19Z734N46Z9N80Z73N8Z29N20Z733N44Z13N81Z71N9Z27N17Z728N50Z17N83Z68N14Z10N25Z733N48Z19N85Z65N17Z4N22Z740N45Z22N87Z63N42Z741N40Z25N92Z58N43Z742N38Z27N94Z56N43Z742N34Z31N98Z54N40Z743N32Z33N100Z2N22Z28N40Z743N30Z34N128Z25N38Z745N27Z36N132Z23N34Z748N25Z37N135Z25N30Z748N20Z40N143Z10N9Z6N37Z2N10Z723N15Z45N45Z2N116Z6N50Z721N8Z51N45Z4N115Z9N51Z775N46Z5N114Z11N50Z774N45Z9N111Z12N49Z774N45Z14N106Z14N50Z772N43Z15N103Z18N50Z775N37Z19N15Z3N80Z23N49Z779N31Z21N12Z6N77Z25N50Z784N24Z25N5Z12N73Z29N50Z783N22Z45N71Z30N49Z12N6Z768N17Z48N69Z31N50Z10N12Z769N5Z58N62Z36N68Z835N59Z40N66Z47N12Z777N54Z50N59Z40N28Z770N52Z57N53Z37N33Z770N47Z64N49Z36N36Z769N44Z67N48Z33N40Z768N42Z70N47Z31N45Z764N36Z81N15Z3N25Z28N50Z12N5Z28N12Z705N35Z87N4Z10N24Z27N53Z10N6Z25N15Z64N8Z632N28Z54N8Z48N20Z28N55Z7N9Z20N20Z45N6Z7N20Z625N27Z54N10Z47N20Z28N56Z4N12Z18N22Z14N3Z26N35Z625N24Z56N11Z48N17Z29N75Z15N24Z12N3Z23N37Z628N17Z60N15Z46N15Z30N85Z4N26Z10N7Z18N39Z631N10Z64N17Z11N7Z26N14Z30N87Z1N29Z8N18Z7N38Z705N38Z27N4Z38N117Z6N62Z708N39Z66N119Z6N58Z712N40Z65N173Z694N12Z16N42Z63N164Z701N18Z12N43Z62N158Z705N25Z7N47Z58N155Z707N27Z6N49Z56N155Z705N29Z6N52Z52N156Z704N31Z3N54Z51N157Z703N89Z50N158Z702N91Z47N162Z75N10Z27N14Z574N91Z47N162Z73N14Z24N20Z17N19Z531N94Z45N163Z71N17Z22N63Z525N94Z30N1Z14N164Z70N19Z18N67Z521N95Z16N23Z6N164Z71N17Z19N70Z515N29Z5N65Z14N26Z5N164Z72N16Z19N71Z508N29Z11N65Z12N29Z3N163Z74N16Z18N72Z504N24Z20N64Z10N131Z5N61Z56N2Z18N15Z18N75Z500N24Z21N64Z10N78Z15N37Z7N59Z57N4Z19N12Z17N76Z500N22Z23N64Z10N75Z21N32Z9N64Z51N9Z17N9Z18N82Z494N21Z24N7Z2N53Z12N73Z23N15Z9N6Z11N69Z46N10Z18N6Z17N88Z490N16Z29N6Z4N51Z14N62Z35N8Z31N76Z38N11Z38N95Z486N11Z34N6Z5N50Z14N61Z40N1Z33N16Z3N60Z36N11Z36N98Z485N7Z38N5Z7N49Z14N60Z75N15Z10N55Z35N12Z34N100Z35N11Z289N3Z147N3Z55N46Z15N41Z5N13Z73N15Z17N52Z33N13Z33N36Z4N62Z32N17Z261N9Z224N44Z15N42Z5N13Z72N16Z18N51Z33N16Z30N36Z4N61Z31N20Z260N14Z221N39Z16N44Z6N12Z71N19Z16N51Z33N18Z27N37Z3N58Z34N26Z255N15Z220N38Z17N43Z7N13Z69N20Z16N51Z33N20Z23N39Z3N57Z34N30Z252N17Z220N33Z19N44Z7N13Z69N20Z16N51Z31N23Z20N42Z2N55Z36N32Z250N18Z220N29Z22N44Z7N13Z67N22Z17N49Z32N24Z16N97Z41N36Z246N18Z221N25Z25N44Z7N14Z65N23Z17N50Z31N28Z10N97Z45N35Z245N17Z226N16Z29N45Z5N22Z58N22Z19N51Z28N86Z3N50Z51N34Z238N17Z227N11Z33N46Z4N24Z55N23Z19N51Z27N87Z4N49Z55N35Z233N15Z273N75Z32N44Z20N51Z23N89Z10N46Z61N36Z225N15Z273N75Z29N46Z21N51Z22N88Z15N43Z67N32Z223N14Z274N76Z26N48Z22N50Z20N64Z4N19Z21N40Z71N29Z222N14Z274N76Z24N47Z25N57Z13N60Z50N37Z77N26Z220N14Z275N75Z21N48Z27N60Z9N60Z51N35Z80N25Z220N13Z277N75Z17N47Z33N11Z12N39Z4N57Z58N27Z88N25Z217N12Z280N73Z17N46Z34N10Z13N95Z63N26Z90N24Z217N10Z284N73Z13N47Z35N7Z18N45Z6N36Z71N22Z92N26Z215N9Z288N68Z15N45Z37N7Z18N45Z6N35Z81N11Z93N27Z215N7Z296N20Z4N36Z16N43Z40N7Z18N46Z5N34Z185N28Z527N7Z10N28Z22N39Z44N8Z17N48Z2N32Z186N29Z529N5Z14N21Z26N38Z45N8Z17N81Z187N29Z530N3Z23N8Z30N36Z48N8Z17N67Z9N2Z189N29Z594N36Z49N8Z17N66Z201N28Z597N33Z50N8Z17N67Z40N3Z157N26Z609N21Z23N9Z21N6Z18N71Z35N7Z157N21Z616N14Z24N15Z16N6Z19N71Z33N11Z155N19Z428N18Z206N21Z14N4Z20N71Z31N37Z132N11Z433N24Z202N21Z15N2Z22N70Z31N37Z135N6Z432N32Z196N25Z10N6Z21N69Z30N39Z574N30Z196N26Z4N20Z12N68Z30N41Z573N31Z195N52Z12N65Z28N45Z573N34Z191N55Z12N59Z28N50Z572N34Z190N55Z16N11Z7N36Z27N52Z573N39Z183N57Z35N31Z27N57Z100N3Z427N3Z41N36Z184N56Z36N29Z26N59Z99N5Z476N20Z196N55Z39N21Z27N63Z90N18Z690N52Z42N16Z27N65Z87N23Z690N52Z43N9Z30N66Z84N30Z524N4Z168N47Z75N70Z81N39Z513N8Z169N46Z72N72Z81N42Z312N5Z192N10Z170N41Z72N75Z78N48Z307N8Z191N11Z172N35Z73N77Z76N50Z307N10Z189N11Z175N29Z74N77Z75N54Z20N1Z282N6Z5N5Z186N13Z272N80Z14N9Z48N83Z276N10Z3N7Z185N14Z270N80Z7N19Z45N85Z270N31Z179N14Z269N80Z7N21Z42N88Z269N33Z177N14Z267N83Z5N22Z42N87Z266N4Z15N19Z179N8Z269N111Z39N55Z13N20Z268N3Z6N29Z179N7Z270N111Z39N54Z15N16Z268N6Z5N31Z180N3Z271N112Z38N54Z17N11Z272N5Z5N32Z451N117Z33N54Z303N5Z5N32Z451N115Z33N56Z305N34Z456N115Z30N58Z307N30Z460N114Z30N57Z313N21Z464N112Z30N57Z21N6Z290N18Z465N112Z31N55Z23N6Z293N10Z470N111Z31N55Z23N8Z762N120Z27N65Z18N7Z760N121Z25N72Z15N7Z753N127Z23N81Z7N9Z686N2Z62N130Z21N84Z5N10Z688N1Z61N129Z21N86Z2N12Z688N1Z60N129Z21N100Z46N4Z35N10Z654N128Z23N99Z47N6Z32N13Z445N7Z97N1Z100N128Z24N98Z48N12Z24N28Z432N10Z94N2Z100N127Z23N99Z49N14Z21N30Z430N12Z88N9Z97N124Z25N101Z48N20Z8N40Z427N15Z83N12Z97N121Z28N100Z49N70Z423N17Z82N13Z97N119Z29N101Z47N73Z421N19Z81N13Z97N114Z30N101Z49N75Z421N19Z81N13Z97N111Z32N101Z49N76Z421N18Z82N13Z96N109Z30N103Z45N84Z420N18Z82N13Z96N107Z30N104Z44N86Z116N7Z298N15Z83N10Z100N104Z31N105Z42N89Z423N12Z81N17Z95N103Z30N108Z44N87Z424N11Z79N19Z93N104Z28N110Z45N87Z426N9Z75N24Z90N105Z26N111Z48N86Z428N6Z74N16Z6N4Z89N105Z26N112Z49N84Z430N5Z66N20Z13N1Z86N108Z26N111Z51N83Z432N2Z67N13Z2N3Z100N110Z25N111Z54N81Z501N10Z106N112Z25N111Z54N80Z501N6Z110N111Z25N112Z58N75Z503N5Z111N111Z24N113Z45N7Z8N73Z502N5Z112N110Z24N112Z33N22Z9N69Z504N5Z112N109Z25N111Z30N26Z10N67Z505N3Z89N16Z8N107Z25N114Z29N31Z3N67Z508N3Z87N131Z26N114Z29N101Z510N2Z85N132Z25N116Z27N102Z492N6Z99N130Z21N120Z28N102Z492N11Z95N130Z21N120Z28N102Z491N14Z93N127Z23N118Z29N104Z492N19Z88N126Z21N120Z30N103Z493N22Z81N127Z22N120Z30N102Z495N24Z79N126Z22N120Z30N104Z495N24Z77N127Z22N120Z31N103Z496N24Z76N126Z23N119Z31N104Z495N25Z77N124Z24N118Z33N102Z350N9Z136N25Z79N121Z24N119Z37N99Z346N29Z121N25Z79N121Z23N120Z40N95Z346N43Z108N24Z80N119Z24N118Z45N93Z316N1Z27N51Z102N23Z80N117Z25N118Z49N90Z317N3Z25N53Z100N22Z81N116Z25N116Z52N88Z319N5Z23N55Z100N16Z86N113Z26N116Z51N87Z322N5Z23N56Z99N15Z88N110Z28N115Z50N87Z325N5Z24N55Z99N11Z94N105Z27N117Z50N86Z327N7Z25N53Z98N10Z97N99Z30N118Z48N88Z327N7Z27N53Z98N7Z100N92Z34N117Z50N88Z327N8Z32N49Z205N85Z38N117Z51N87Z328N8Z34N47Z206N83Z37N119Z51N85Z330N8Z36N45Z208N81Z34N120Z53N82Z333N8Z36N45Z209N79Z32N120Z56N80Z334N10Z38N42Z213N75Z30N117Z63N76Z336N10Z39N41Z216N72Z28N117Z65N75Z336N11Z39N41Z219N69Z28N114Z68N75Z336N11Z34N45Z222N2Z10N53Z30N113Z69N73Z338N11Z29N49Z236N51Z30N111Z72N73Z338N10Z27N49Z243N46Z30N110Z72N74Z339N10Z27N48Z247N42Z31N107Z75N74Z339N10Z26N48Z251N37Z32N106Z76N74Z337N12Z27N48Z252N35Z31N107Z72N78Z338N10Z29N48Z252N34Z32N107Z70N78Z340N7Z31N49Z221N9Z25N28Z33N107Z70N78Z342N3Z35N50Z217N13Z27N24Z31N109Z71N78Z379N51Z105N6Z105N21Z33N7Z29N114Z71N31Z10N35Z382N51Z105N7Z104N28Z62N113Z72N33Z8N34Z383N50Z107N4Z106N31Z58N114Z72N74Z385N47Z218N34Z55N112Z76N69Z389N46Z219N35Z52N114Z76N68Z390N25Z5N15Z220N36Z50N114Z80N61Z394N24Z8N12Z220N37Z50N113Z83N57Z382N4Z10N22Z14N3Z78N3Z40N1Z59N10Z31N43Z46N112Z88N51Z383N11Z5N22Z93N6Z28N17Z49N16Z28N48Z42N112Z90N50Z381N13Z5N22Z92N10Z23N23Z42N22Z22N56Z37N112Z90N50Z350N1Z27N18Z2N22Z90N15Z21N25Z37N30Z11N66Z31N112Z92N50Z349N2Z25N43Z87N20Z19N28Z33N110Z30N110Z94N49Z325N5Z19N3Z23N42Z87N28Z10N34Z28N90Z5N18Z29N110Z96N48Z324N6Z19N3Z22N28Z100N33Z5N55Z4N93Z8N16Z29N110Z96N48Z325N6Z17N4Z20N26Z103N191Z10N14Z29N111Z96N48Z323N8Z14N7Z15N30Z103N191Z16N3Z33N110Z99N45Z325N9Z11N9Z14N32Z101N192Z53N110Z99N44Z325N10Z10N10Z12N33Z99N195Z52N109Z101N43Z326N10Z9N10Z13N33Z97N195Z54N109Z100N44Z325N11Z5N6Z21N33Z95N195Z56N106Z103N41Z328N11Z5N2Z27N31Z94N195Z57N105Z104N41Z328N11Z4N2Z28N30Z91N197Z58N105Z105N40Z329N8Z7N1Z29N28Z90N199Z59N102Z54N15Z39N39Z330N7Z6N2Z30N27Z90N199Z60N101Z48N2Z1N20Z38N37Z332N6Z37N27Z88N197Z66N99Z46N41Z26N34Z333N5Z38N25Z89N194Z70N97Z47N46Z24N31Z376N25Z88N191Z75N95Z46N51Z25N24Z380N24Z89N188Z78N95Z46N53Z25N21Z381N23Z91N186Z79N94Z45N55Z26N19Z385N5Z110N176Z85N92Z44N59Z26N13Z391N2Z113N172Z88N91Z45N60Z28N7Z513N163Z93N89Z48N59Z309N12Z228N21Z1N140Z93N86Z51N59Z306N18Z227N17Z3N139Z94N85Z52N60Z302N23Z228N11Z6N139Z58N13Z23N81Z58N58Z300N28Z226N9Z7N138Z56N18Z21N80Z59N60Z293N45Z222N146Z52N25Z18N77Z62N62Z288N51Z212N152Z50N28Z18N76Z63N63Z294N10Z1N35Z204N156Z42N40Z16N74Z63N68Z292N9Z3N35Z201N157Z38N44Z16N71Z66N68Z292N8Z4N36Z199N157Z36N48Z15N70Z67N69Z293N7Z1N42Z192N159Z35N50Z15N66Z70N70Z293N52Z188N161Z34N51Z15N65Z70N71Z293N53Z183N161Z36N52Z15N65Z70N72Z293N55Z180N161Z37N52Z15N63Z70N74Z293N56Z177N160Z39N53Z15N62Z70N75Z294N55Z177N160Z39N53Z13N63Z70N76Z298N51Z177N159Z41N50Z17N61Z69N77Z304N45Z176N159Z42N48Z19N58Z70N78Z309N41Z176N156Z45N45Z22N57Z70N79Z312N37Z88N13Z75N154Z50N40Z25N56Z69N81Z312N37Z86N17Z73N152Z53N37Z27N55Z68N83Z314N35Z83N23Z70N151Z54N36Z28N55Z67N84Z315N34Z81N30Z64N150Z56N21Z6N5Z30N55Z67N83Z319N31Z82N35Z58N149Z59N15Z47N55Z65N85Z322N27Z81N42Z51N149Z61N7Z54N54Z66N86Z325N23Z81N44Z49N148Z63N6Z55N53Z67N85Z344N4Z81N47Z43N150Z125N45Z75N86Z429N56Z33N150Z127N43Z76N85Z429N60Z27N150Z130N41Z79N84Z429N62Z21N152Z133N39Z80N81Z430N64Z20N151Z135N38Z81N81Z428N67Z18N149Z61N1Z78N36Z81N78Z430N71Z15N149Z140N35Z82N78Z427N81Z8N146Z143N33Z84N75Z429N85Z4N145Z145N32Z86N73Z429N87Z3N143Z147N31Z87N72Z427N231Z152N27Z93N68Z429N230Z153N26Z95N67Z428N230Z156N24Z57N9Z35N60Z429N230Z157N22Z56N16Z33N56Z430N229Z160N20Z53N22Z32N53Z431N226Z168N11Z56N25Z36N45Z432N226Z235N26Z39N41Z433N223Z49N3Z186N26Z44N34Z436N222Z239N25Z46N30Z439N219Z242N22Z53N23Z441N216Z245N20Z58N20Z442N214Z248N16Z61N18Z445N57Z13N111Z280N12Z68N11Z448N57Z13N108Z284N10Z71N7Z452N61Z7N107Z289N4Z533N62Z6N106Z828N62Z5N103Z831N61Z11N94Z835N60Z13N88Z842N157Z843N157Z846N154Z71N22Z756N151Z70N24Z757N149Z68N27Z715N4Z41N145Z66N30Z712N11Z36N146Z64N31Z704N28Z31N145Z60N34Z698N35Z35N138Z60N34Z692N48Z36N131Z58N36Z690N50Z36N130Z56N39Z688N52Z35N130Z45N50Z688N56Z34N126Z37N62Z683N60Z33N125Z36N64Z682N64Z34N117Z37N70Z678N67Z33N115Z37N70Z677N71Z34N110Z35N76Z673N75Z32N108Z36N91Z657N77Z33N106Z35N99Z641N91Z31N99Z38N102Z635N99Z29N96Z37N105Z629N110Z25N86Z43N109Z626N115Z22N83Z44N110Z623N120Z20N82Z45N110Z621N125Z17N77Z50N108Z620N128Z17N75Z50N109Z618N133Z17N71Z52N108Z617N135Z17N71Z51N108Z615N141Z14N68Z54N106Z614N151Z5N69Z55N105Z599N9Z5N226Z55N106Z591N247Z55N107Z590N248Z55N106Z589N192Z1N55Z53N110Z589N247Z50N115Z585N248Z46N125Z581N246Z47N127Z579N246Z46N129Z576N208Z10N29Z46N132Z574N209Z12N25Z47N133Z573N211Z15N20Z40N141Z572N215Z15N15Z40N142Z571N218Z17N2Z48N144Z570N220Z64N146Z569N221Z64N145Z562N229Z63N145Z558N234Z63N142Z560N235Z61N142Z562N234Z61N141Z563N235Z61N140Z564N234Z61N107Z14N18Z566N234Z61N111Z11N14Z569N230Z66N113Z12N1Z578N229Z67N114Z590N226Z71N113Z590N225Z72N114Z589N224Z75N112Z590N221Z79N109Z592N219Z81N108Z595N214Z86N105Z596N211Z89N104Z597N210Z90N103Z600N205Z94N100Z602N203Z55N7Z34N97Z608N195Z52N18Z37N90Z612N190Z52N20Z40N85Z618N182Z54N34Z33N78Z620N180Z54N37Z34N75Z620N179Z53N42Z32N73Z623N172Z57N48Z32N65Z590N3Z35N167Z59N50Z34N62Z586N12Z33N159Z61N57Z45N45Z588N13Z34N156Z61N60Z44N42Z589N15Z35N153Z58N68Z41N40Z590N16Z35N150Z59N71Z39N40Z590N19Z36N145Z59N75Z37N38Z591N21Z48N130Z54N86Z34N33Z594N21Z52N81Z4N40Z52N90Z34N31Z595N23Z55N73Z9N29Z59N95Z33N27Z597N24Z55N72Z10N24Z61N98Z34N23Z600N24Z56N70Z12N21Z62N99Z34N21Z601N28Z55N67Z15N12Z67N104Z32N15Z607N26Z56N66Z94N104Z34N11Z609N27Z20N9Z29N63Z94N105Z35N4Z615N27Z18N11Z28N63Z93N106Z36N2Z617N26Z20N9Z29N62Z90N109Z656N27Z20N7Z29N62Z89N110Z658N25Z21N6Z29N62Z88N111Z660N24Z22N2Z32N60Z85N115Z660N25Z30N1Z25N59Z84N116Z664N24Z26N5Z22N59Z83N118Z664N25Z24N5Z22N59Z81N122Z667N29Z15N10Z22N54Z78N126Z667N30Z14N24Z11N50Z76N129Z668N28Z14N25Z14N46Z75N133Z666N29Z11N26Z18N42Z73N137Z666N29Z5N30Z19N41Z71N139Z673N56Z22N39Z69N141Z675N54Z25N36Z69N141Z676N40Z2N10Z28N34Z68N142Z683N32Z46N29Z65N146Z685N30Z47N27Z64N146Z690N36Z39N24Z62N148Z67N15Z610N37Z38N23Z61N148Z67N19Z609N36Z41N18Z58N150Z68N21Z608N37Z41N17Z57N150Z68N23Z608N37Z42N13Z59N149Z69N23Z609N46Z102N150Z70N23Z610N50Z95N150Z72N23Z613N55Z84N150Z76N22Z614N56Z79N151Z79N21Z615N60Z72N151Z82N20Z617N58Z70N153Z84N17Z620N56Z70N152Z86N14Z628N50Z69N151Z89N10Z634N47Z68N151Z91N8Z635N46Z68N147Z99N4Z637N45Z68N136Z751N44Z67N137Z755N37Z70N135Z759N35Z70N136Z763N27Z70N139Z765N25Z69N141Z769N21Z65N144Z772N19Z65N142Z775N18Z65N142Z778N15Z65N141Z780N14Z65N140Z784N11Z65N139Z786N10Z65N139Z862N136Z865N135Z867N132Z870N129Z871N129Z874N123Z878N121Z880N119Z884N115Z887N111Z894N105Z898N101Z905N91Z923N76Z926N71Z933N65Z936N63Z940N56Z945N54Z853N2Z92N15Z3N28Z860N2Z93N13Z4N27Z860N3Z93N12Z6N25Z959N8Z9N23Z961N6Z11N20Z965N2Z16N17Z985N14Z988N12Z993N5Z997N1Z13069N6Z994N9Z990N14Z985N13Z987N12Z988N8Z992N8Z990N9Z991N8Z994N5Z996N4Z997N1Z19950N4Z41701N",
                "defect_id": 152879,
                "label_index": 2,
                "label_name": "Other"
            }
        },
        "data": null,
        "labels": null,
        "num_classes": 3
    },
    "type": "SegmentationPrediction",
    "latency": {
        "preprocess_s": 0.0034046173095703125,
        "infer_s": 0.6407222747802734,
        "postprocess_s": 7.05718994140625e-05,
        "serialize_s": 0.05350923538208008,
        "input_conversion_s": 0.01775670051574707,
        "model_loading_s": 8.249282836914062e-05
    },
    "model_id": "fdb43e8d-c316-4e16-a7ae-08d7454a83de"
}
```

<img alt="JSON_VP_ShippingContainers" />

### Script for Parsing Segmentation and Visual Prompting Results

Use this [Colab notebook](https://colab.research.google.com/drive/17oLfZ9BO_lcBN9p3G36qBM2efFrqH2i5?usp=sharing) to parse the JSON results from Segmentation and Visual Prompting models.

## JSON Responses for Classification Models

The following table describes the objects in the JSON response for Classification models. An example response is [here](./json-responses#example-classification-json-response).

| Element                                       | Description                                                                                                                                                                                                                                                                                                                                                                                                 |
| --------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `backbonetype` (Cloud Deployment)             | This object isn’t applicable to Classification models, because the prediction type is captured in the `type` object. For Classification, this will always be `null`.<br /><br />This element only displays in the JSON response for Cloud Deployment.                                                                                                                                                       |
| `backbonepredictions` (Cloud Deployment)      | This object isn’t applicable to Classification models, because the prediction type is captured in predictions. For Classification, this will always be `null`.<br /><br />This element only displays in the JSON response for Cloud Deployment.                                                                                                                                                             |
| `predictions`                                 | This object contains the information for the model's prediction.                                                                                                                                                                                                                                                                                                                                            |
| `score`                                       | The confidence score for the prediction.                                                                                                                                                                                                                                                                                                                                                                    |
| `labelName`                                   | The predicted class.                                                                                                                                                                                                                                                                                                                                                                                        |
| `labelIndex`                                  | The internal identifier of the predicted class. Each class in a project is assigned a number, starting with 0. If you delete a class, that class’s number is not re-assigned to any current or future classes in that project.                                                                                                                                                                              |
| `defectId` (LandingEdge, Docker)              | The unique identifier for the predicted class.<br /><br />This element only displays in the JSON response for LandingEdge and Docker.                                                                                                                                                                                                                                                                       |
| `rawScores` (LandingEdge, Docker)             | <br /><br />This element only displays in the JSON response for LandingEdge and Docker.                                                                                                                                                                                                                                                                                                                     |
| `"type": "ClassificationPrediction"`          | The name of the prediction type. For Classification, this will always be ClassificationPrediction.                                                                                                                                                                                                                                                                                                          |
| `metadata` (LandingEdge, Docker)              | This element contains nested metadata from the image. If the [Image Source](./landingedge/manage-inspection-points#image-source) is **Folder Watcher**, some data is populated by default. You can use [scripts](./landingedge/custom-processing#add-metadata-to-images) and web APIs to set or override the values.<br /><br />This element only displays in the JSON response for LandingEdge and Docker. |
| `image_id` (LandingEdge, Docker)              | If the [Image Source](./landingedge/manage-inspection-points#image-source) is **Folder Watcher**, this is the file name of the image. Otherwise, this object is blank. You can use [scripts](./landingedge/custom-processing#add-metadata-to-images) and web APIs to set or override the values.<br /><br />This element only displays in the JSON response for LandingEdge and Docker.                     |
| `inspection_station_id` (LandingEdge, Docker) | This element is blank by default. You can use [scripts](./landingedge/custom-processing#add-metadata-to-images) and web APIs to set or override the values.<br /><br />This element only displays in the JSON response for LandingEdge and Docker.                                                                                                                                                          |
| `location_id` (LandingEdge, Docker)           | If the [Image Source](./landingedge/manage-inspection-points#image-source) is **Folder Watcher**, this is the directory that the image is in. Otherwise, this object is blank. You can use [scripts](./landingedge/custom-processing#add-metadata-to-images) and web APIs to set or override the values.<br /><br />This element only displays in the JSON response for LandingEdge and Docker.             |
| `capture_timestamp` (LandingEdge, Docker)     | The time and date that OCR was run on the image. You can use [scripts](./landingedge/custom-processing#add-metadata-to-images) and web APIs to set or override the values.<br /><br />This element only displays in the JSON response for LandingEdge and Docker.                                                                                                                                           |
| `latency`                                     | The `latency` object includes the detailed timing statistics of the inference call.Each key-value pair in the `latency` object represents a step in the inference process, and the duration of that step. All values are measured in seconds.                                                                                                                                                               |
| `model_id`                                    | The unique identifier for the deployed model, which is specific to the model and its threshold. This is the value that **Copy Model ID** copies from the **Actions** menu on the [Models page](./models-page).                                                                                                                                                                                              |

### Example: Classification JSON Response

The following code snippet and image show the predictions for a Classification model trained to detect defects on metal sheets. The model has three classes: Pitted, Scratched, and No Defect. The model correctly predicted the Scratched class.

The prediction data is in the `predictions` object.

This JSON response is from Cloud Deployment.

```json theme={null}
{
    "backbonetype": null,
    "backbonepredictions": null,
    "predictions": {
        "score": 0.9992166757583618,
        "labelName": "Scratched",
        "labelIndex": 1
    },
    "type": "ClassificationPrediction",
    "latency": {
        "preprocess_s": 0.005140542984008789,
        "infer_s": 0.14725708961486816,
        "postprocess_s": 6.794929504394531e-05,
        "serialize_s": 0.00016546249389648438,
        "input_conversion_s": 0.0007550716400146484,
        "model_loading_s": 5.677931785583496
    },
    "model_id": "6924128f-3526-4d02-97c5-281f8a6984c1"
}
```

<img alt="JSON_CLASS_MetalScratch" />

## JSON Responses for Anomaly Detection Models

The following table describes the objects in the JSON response for Anomaly Detection models. An example response is [here](./json-responses#example-anomaly-detection-json-response).

| Element                                                                           | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| --------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `backbonetype` (Cloud Deployment)<br />`type` (LandingEdge, Docker)               | The name of the prediction type. For Anomaly Detection, this will always be `AnomalyDetectionPrediction`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| `backbonepredictions` (Cloud Deployment)<br />`predictions` (LandingEdge, Docker) | This object contains the prediction information.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| `score`                                                                           | The confidence score for the prediction.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| `defect_id`<br />                                                                 | The unique identifier for the predicted class.<br />                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| `labelIndex`<br />                                                                | The internal identifier of the predicted class. Normal is 0. Abnormal is 1.<br />                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| `labelName`                                                                       | The predicted class.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| `predictions` (Cloud Deployment)                                                  | When an image is sent for inference via Cloud Deployment, it goes through the model, and then through a post-processing Classification step. The `predictions` object contains the results from the Classification step. This step classifies the image as `"OK"` or `"NG"` (short for "Not Good").<br /><br />This step simplifies defect detection. For example, if a model checks sheet metal for scratches, the metal should be marked as defective regardless if there are one or many scratches.<br /><br />`score`: Confidence score for the Classification prediction.<br />`labelName`: If the number of predictions is > 0 then `"NG"`, else `"OK"`.<br /><br />This element is only applicable to Cloud Deployment. Inference run via LandingEdge and Docker does not include the post-processing Classification step. |
| `"type": "ClassificationPrediction"` (Cloud Deployment)                           | When an image is sent for inference via Cloud Deployment, it goes through the model, and then through a post-processing Classification step. This object is the prediction type of the post-processing Classification step.<br /><br />This element is only applicable to Cloud Deployment. Inference run via LandingEdge and Docker does not include the post-processing Classification step.                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| `metadata` (LandingEdge, Docker)                                                  | This element contains nested metadata from the image. If the [Image Source](./landingedge/manage-inspection-points#image-source) is **Folder Watcher**, some data is populated by default. You can use [scripts](./landingedge/custom-processing#add-metadata-to-images) and web APIs to set or override the values.<br /><br />This element only displays in the JSON response for LandingEdge and Docker.                                                                                                                                                                                                                                                                                                                                                                                                                       |
| `image_id` (LandingEdge, Docker)                                                  | If the [Image Source](./landingedge/manage-inspection-points#image-source) is **Folder Watcher**, this is the file name of the image. Otherwise, this object is blank. You can use [scripts](./landingedge/custom-processing#add-metadata-to-images) and web APIs to set or override the values.<br /><br />This element only displays in the JSON response for LandingEdge and Docker.                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| `inspection_station_id` (LandingEdge, Docker)                                     | This element is blank by default. You can use [scripts](./landingedge/custom-processing#add-metadata-to-images) and web APIs to set or override the values.<br /><br />This element only displays in the JSON response for LandingEdge and Docker.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| `location_id` (LandingEdge, Docker)                                               | If the [Image Source](./landingedge/manage-inspection-points#image-source) is **Folder Watcher**, this is the directory that the image is in. Otherwise, this object is blank. You can use [scripts](./landingedge/custom-processing#add-metadata-to-images) and web APIs to set or override the values.<br /><br />This element only displays in the JSON response for LandingEdge and Docker.                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| `capture_timestamp` (LandingEdge, Docker)                                         | The time and date that OCR was run on the image. You can use [scripts](./landingedge/custom-processing#add-metadata-to-images) and web APIs to set or override the values.<br /><br />This element only displays in the JSON response for LandingEdge and Docker.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| `latency`                                                                         | The `latency` object includes the detailed timing statistics of the inference call.Each key-value pair in the `latency` object represents a step in the inference process, and the duration of that step. All values are measured in seconds.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `model_id`                                                                        | The unique identifier for the deployed model, which is specific to the model and its threshold. This is the value that **Copy Model ID** copies from the **Actions** menu on the [Models page](./models-page).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |

### Example: Anomaly Detection JSON Response

The following code snippet and image show the predictions for an Anomaly Detection model for detecting if PCB boards are assembled correctly. The model correctly predicted the image as Normal.

The prediction data is in the `backbonepredictions` object.

This JSON response is from Cloud Deployment.

```json theme={null}
{
    "backbonetype": "AnomalyDetectionPrediction",
    "backbonepredictions": {
        "score": 0.2786782383918762,
        "defect_id": 132080,
        "label_index": 0,
        "label_name": "normal"
    },
    "predictions": {
        "score": 0.2786782383918762,
        "labelName": "normal",
        "labelIndex": 0
    },
    "type": "ClassificationPrediction",
    "latency": {
        "preprocess_s": 0.00594639778137207,
        "infer_s": 0.39536023139953613,
        "postprocess_s": 0.00012087821960449219,
        "serialize_s": 0.0001537799835205078,
        "input_conversion_s": 0.007228374481201172,
        "model_loading_s": 0.00015592575073242188
    },
    "model_id": "b54f2ca2-5dbc-4447-821e-2d0fa377ca49"
}
```

<img alt="anomaly_detection_prediction" />


# July 2022 Release Notes
Source: https://landinglens.docs.landing.ai/july-2022-release-notes



## New Features

* Launched a new Support Center that includes new and improved documentation.
* Added [Classification](./classification) to the improved workflow that allows for faster Model creation and training. (Previously this workflow only supported Object Detection and Segmentation.) (Beta feature\*)
* Added a new Project Type called **Anomaly Detection**. Anomaly Detection is used to identify any deviations from the norm and can be trained entirely on images without the Class you're looking for. (Beta feature\*)

\*Beta features are deactivated by default. If you would like a Beta feature to be activated, please contact .## Improvements

* Improved performance for datasets of 50 or fewer images. This development also increased the Model training speed by about 10%.
* Increased memory limitations from 2GB to 3GB for Model training.

## Bug Fixes

* Fixed issue where the LandingLens user interface randomly closed and restarted.
* Fixed issue where Inspection Points in LandingEdge didn't save properly.
* Fixed issue where Inspection Start times in LandingEdge reverted to 5 seconds if the interval was set to less than 1 second.
* Fixed issue where BMP images didn't load properly in LandingEdge input folders.
* Fixed issue where the zoom levels were the same for all images when running inference in LandingEdge.
* Fixed issue where Model names in LandingEdge weren't being saved.


# Label Assist
Source: https://landinglens.docs.landing.ai/label-assist



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

The **Label Assist** tool suggests new labels or improvements to labels after training a model in an Object Detection project. Use Label Assist to speed up the labeling process and help make your labels ("ground truth" annotations) more accurate, so that the next model will have better performance.

Label Assist can spot missing labels and suggest label improvements. For example, if there's a large space between an object and the original bounding box, Label Assist might suggest a tighter label.

Label Assist shows you its suggestions on the image details page as dashed bounding boxes. Click a suggestion to accept it, or click **Accept All** to accept all suggestions for an image. After reviewing and accepting suggestions, train the model again to include the newest labels in a model.

<img alt="LabelAssist_Overview" />

## Label Assist Requirements

* Label Assist is only available for Object Detection projects.
* A model must be created for Label Assist to work. Label Assist offers suggestions based on the predictions of the selected model.

## Use Label Assist

Follow the instruction below to turn on and use Label Assist. To see everything you can do with Label Assist, go to [Actions Available in Label Assist](./label-assist#actions-available-in-label-assist).

1. Open an Object Detection project that you've created a model for.
2. Open the image you want to see suggestions for.
3. If the Image Details panel isn't open, click the **i** button to open it.
4. Click **Label Assist** in the **Predictions** panel.
   <img alt="LabelAssist_enable" />
5. Turning on Label Assist shows the suggestions and puts you in "label mode", which means that you can add and edit labels.
6. Each suggestion is marked with an animated dashed bounding box. Click a suggestion to accept it. This means that the suggestion turns into a label ("ground truth"). For example, in the screenshot below, clicking either of the purple dashed boxes will turn it into a "Hard Hat" label.
   <img alt="LabelAssist_Accept1" />
7. You can also **Click Accept All** to turn all suggestions into ground truths.
   <img alt="LabelAssist_AcceptAll" />
8. You can edit any labels when Label Assist is on. This means you can add, resize, and delete labels.
9. When you're done reviewing and accepting suggestions, click the toggle next to **Label Assist**.
   <img alt="LabelAssist_disable" />
10. If you want to see Predictions again, click the **Pan** icon or press **a** to exit "label mode".
    <img alt="LabelAssist_AddPredictions(1)" />

## Actions Available in Label Assist

You can perform the following actions when the Label Assist tool is on.

| Goal                           | Actions and More Information                                                                                                                                                                                                                                                                                                                                            |
| ------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Accept a suggestion            | Click the suggestion (the animated dashed bounding box).                                                                                                                                                                                                                                                                                                                |
| Accept all suggestions         | Click **Accept All**.                                                                                                                                                                                                                                                                                                                                                   |
| See different suggestions      | Move the **Confidence Threshold** slider to show more or fewer suggestions. Higher thresholds typically yield fewer suggestions. Changing the threshold here doesn't change the model’s actual threshold.                                                                                                                                                               |
| Make suggestions more accurate | Suggestions might not be completely accurate. For example, there might be too much space between the bounding box and the object of interest. In this situation, click a suggestion to accept it. Then resize and move the label.<br /><br />You can resize and move all labels when Label Assist is on, including the labels that were added before the model trained. |
| Don't accept wrong suggestions | If a suggestion is wrong, simply ignore it.                                                                                                                                                                                                                                                                                                                             |
| Turn off Label Assist          | When you're done reviewing and accepting suggestions, click the toggle next to **Label Assist**.                                                                                                                                                                                                                                                                        |

## Run Label Assist on Images Uploaded After Training a Model

If you upload an image to a project after a model was trained, the model won't have any predictions for the image yet, which means that Label Assist won't have any suggestions.

To get a suggestion on an image uploaded after a model was trained, turn on Label Assist and click **Get Suggestion**. This will cost 1 credit because the image makes a prediction on the image. (The credit cost is not applicable when using .)

<img alt="LabelAssist_GetSuggest" />


# Label View Settings
Source: https://landinglens.docs.landing.ai/label-view-settings



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

## General Settings

When you click to open an image, you can manage the labels of that image. This view is called **label view**. There are several settings in this view, as described in the table below.

Each project type has its own settings. For more information on those settings, refer to the relevant article based on your project type:

* [Object Detection](./object-detection)
* [Classification](./classification)
* [Segmentation](./segmentation)
* [Anomaly Detection](./anomaly-detection)

<img alt="Image Detail Settings" />

| Icon | Setting                                                        | Description                                                                                                                     | Keyboard Shortcut                                                    |
| ---- | -------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------- |
|      | Back                                                           | Navigate back to the Build page.                                                                                                | N/A                                                                  |
|      | Previous/Next                                                  | Go to the previous or next image.                                                                                               | <br />←/→                                                            |
|      | Pan                                                            | Click and drag to move the image. Using this tool does not affect any labels.                                                   | a                                                                    |
|      | Undo                                                           | Undo the last action.                                                                                                           | Ctrl+Z (for Windows)<br />Command+Z (for Mac)<br /><br />            |
|      | Redo                                                           | Redo the last action you undid.                                                                                                 | Shift+Ctrl+Z (for Windows)<br />Shift+Command+Z (for Mac)            |
|      | Remove All Labels                                              | Remove all labels from the image. This action cannot be undone.                                                                 | N/A                                                                  |
|      | Enhance                                                        | Adjust the brightness and contrast of the image when labeling images. This adjustment will not impact the original image files. | N/A                                                                  |
|      | Hide                                                           | Hover over this icon to hide your labels.                                                                                       | (hold) h                                                             |
|      | Labels                                                         | Toggle on or off your labels. Only applicable to Object Detection and Segmentation projects.                                    | g                                                                    |
|      | Predictions                                                    | Toggle on or off the model's predictions. Only applicable to Object Detection and Segmentation projects.                        | p                                                                    |
|      | Zoom                                                           | Adjust the size of the image.                                                                                                   | Zoom in: =<br />Zoom out: -<br />Zoom to fit: 0<br />Zoom to 100%: 1 |
|      | [Image details](./label-view-settings#image-details-settings)  | Display or hide information about the image. From this panel, you can also assign splits, tags, and metadata to the image.      | N/A>                                                                 |
|      | [Keyboard shortcuts](./label-view-settings#keyboard-shortcuts) | Display or hide the keyboard shortcuts.                                                                                         | /                                                                    |
|      | Select class                                                   | Select the class you want to label with. Only applicable to Object Detection and Segmentation projects.                         | c                                                                    |
|      | No class                                                       | Use this option if there are no objects to detect in the image. Only applicable to Object Detection and Segmentation projects.  | N/A                                                                  |

## Image Details Settings

When you click the **i** icon, the image details panel displays. On this panel, you can view information about the image, assign splits, and add tags and metadata to the image.

<img alt="label-view-settings" />

| Setting     | Description                                                                                                                                                                                                                                                            |
| ----------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| ID          | The unique ID of the image. You can enter this ID in the Media ID filter on the Build page to display this image. This ID can also be used as the "media\_ID" in APIs.                                                                                                 |
| Dimensions  | The dimensions of the image in pixels.                                                                                                                                                                                                                                 |
| Uploaded    | Approximately when the image was uploaded. Hover over the timeframe to see the exact date and time of upload.                                                                                                                                                          |
| Split       | The image was divided into this subset during model training. You can split the image into a different subset by selecting one. LandingLens will consider this selection the next time you train your model. For more information on splits, go to [Splits](./splits). |
| Tags        | Apply tags (keywords) to the image. Using tags helps you organize and filter images in your dataset. For more information on tags, go [here](./tags).                                                                                                                  |
| Metadata    | Apply metadata to the image. Metadata functions similarly to tags for filtering images. However, users can only choose from a predefined set of options when using metadata.                                                                                           |
| Labels      | View the ground truth labels. The label format depends on the project type.                                                                                                                                                                                            |
| Predictions | View the model's predictions and confidence score. The prediction format depends on the project type.<br />                                                                                                                                                            |


# Labeling
Source: https://landinglens.docs.landing.ai/labeling



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

After you've uploaded images to LandingLens, you can label them. Labeling images is an important step of the model creation process. The labels you provide on images are called **ground truth**. When your model trains, it learns to detect objects of interest by referring to the ground truth, so it's important that your labels are accurate and consistent.

For more information on labeling images using specific labeling tools, refer to the relevant article based on your project type:

* [Object Detection](./object-detection#label-images-with-bounding-boxes)
* [Classification](./classification#add-labels-to-images-in-classification-projects)
* [Segmentation](./segmentation#labeling-tools-for-segmentation)
* [Anomaly Detection](./anomaly-detection)

<Info>Create a [label book](./manage-label-book) to establish clear labeling guidelines and provide proper training to help labelers understand your project's requirements.</Info>

## Label Images

To label images:

1. Click an image to open it.
2. Perform one of the following actions:
   * If the image has no objects of interest to detect, click the **No Class** button. LandingLens marks the image as **No Class**.
     <img alt="No Class" />
   * Use the provided labeling tools to label the object of interest. LandingLens automatically saves the label.
     <img alt="Label Images" />

## Remove Labels From Images

In LandingLens, there are multiple ways to remove labels from images. For example, you can quickly [remove all labels from an image](./labeling#remove-all-labels-from-images) and then relabel it. Or, you can [mark an image as "No Class" to remove all labels](./labeling#remove-all-labels-and-mark-images-as-no-class) from that image.

<Warning>You cannot undo removing labels. However, you can create a snapshot of your data as a backup, and then remove labels. If you later decide you want the labels, you can [restore the snapshot](./dataset-snapshots).</Warning>

### Remove All Labels From Images

Let's say you recently added new classes to your project and need to rework the labels on your images. You can quickly remove all labels from an image. To do this:

1. Click an image to open it.
2. Click the **Remove All Labels** icon.
   <img alt="Remove All Labels Button" />
3. A pop-up window displays. Click **Remove All Labels** in this window to confirm the deletion of the labels. LandingLens automatically removes all labels from the image.
   <img alt="Confirmation" />

### Remove All Labels and Mark Images as "No Class"

Let's say you accidentally labeled an image, but there are no objects to detect in that image. You can quickly remove those labels and mark the image as **No Class**. To do this:

1. Click an image to open it.
2. Click the **No Class** button.
   <img alt="No Class" />
3. A pop-up window displays. Click **Remove All Labels and Mark as No Class** to confirm the action. LandingLens automatically removes all labels in that image and marks it as No Class.
   <img alt="Remove All Labels and Mark as No Class" />


# Configurations
Source: https://landinglens.docs.landing.ai/landingedge/configurations



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

In LandingLens v2.6.45 and later, you can set up multiple *configurations* for each Inspection Point. A **configuration** is the collection of settings for the Inspection Point. Set up multiple configurations if you want to switch between settings without changing the Inspection Point itself.

If you're using a PLC, you can set it up to automatically switch between configurations. For more information about using a PLC with LandingEdge, go to [PLC Workflow](./plc-workflow).

If you're not using a PLC, you can manually change the configuration in the LandingEdge interface.

Configurations are managed in the **Configuration** field at the top of the Inspection Point settings.

<img alt="le_config_intro" />

## If You Don't Need Multiple Configurations

If you don't need multiple configurations for an Inspection Point, ignore the **Configuration** field.

## Shared Settings for Configurations

All configurations you create for an Inspection Point will share the following settings:

* **Communication**: These are the [PLC settings](./plc-workflow).
* **Other Settings**: Controls whether or not the Inspection Point runs automatically when LandingEdge starts.

<img alt="config_shared_settings" />

## Default Configuration

When you create an Inspection Point, LandingEdge automatically creates a configuration that has the same name as your Inspection Point. Any settings you configure are saved to that first configuration.

<img alt="config_ip_default" />

## Create a Configuration

To create a new configuration:

1. Create or open an Inspection Point.
2. Click the **Configuration** drop-down menu and select **Add Configuration**.
   <img alt="le_config_add_1" />
3. Update the **Index** number, if needed. For more information, go to [Configuration Index](./configurations#configuration-index).
4. Enter a short, descriptive name for the configuration in the **Name** field.
5. Click **Create**.
   <img alt="le_config_add_2" />
6. Set up the Inspection Point settings.
7. Click **Save Configuration** when you're done.

## Name a Configuration

To name a configuration:

1. Click the **Configuration** drop-down menu.
2. Click the **Edit** (pencil) icon next to the configuration you want to edit.
   <img alt="le_config_name_1" />
3. Enter a short, descriptive name for the configuration in the **Name** field.
   <img alt="config_name_3" />
4. Click **Save**.

## Configuration Index

When you create a configuration, it's assigned an Index number. Index numbers start with 1 and go up sequentially by 1 (1, 2, 3, etc.).

LandingLens and a PLC use the Index to communicate with each other about the configurations. You can think of the Index as a "code name" for the actual configuration.

If you want a PLC to be able to ask LandingEdge to switch to another configuration, set up these inputs/outputs:

* **Input: Request Sub-Configuration Index**: The PLC can tell LandingEdge to change to a different Inspection Point [configuration](./configurations). Use the configuration Index, and not the configuration name.
* **Outputs: Current Sub-Configuration Index**: LandingEdge tells the PLC the Index of the Inspection Point [configuration](./configurations) that is currently running.

### Change the Configuration Index

To change a configuration Index:

1. Click the **Configuration** drop-down menu.
2. Click the **Edit** (pencil) icon next to the configuration you want to edit.
   <img alt="le_config_index_1" />
3. Enter a positive number in the **Index** field.
   <img alt="config_index_3" />
4. Click **Save**.

## Delete a Configuration

You can delete configurations. However, in order to function, an Inspection Point must have at least one configuration. Therefore, you can't delete all configurations.

To delete a configuration:

1. Click the **Configuration** drop-down menu.
2. Click the **Delete** (trash can) icon for the configuration you want to delete.
   <img alt="le_config_delete" />
3. On the pop-up window that opens, click **Yes, Delete Configuration**.

## Set a Configuration to Run at Startup

You can select which configuration you want to use when the Inspection Point runs. To do this:

1. Click the **Configuration** drop-down menu.
2. Select the **Startup** radio button for the configuration that you want to be used when the Inspection Point runs.
   <img alt="le_config_startup" />

## Configuration Name Displays in LandingLens

When you run inference using the Inspection Point, the configuration name—and not the Inspection Point name —displays on the LandingLens **Deploy** page.

For example, in the screenshots below, the Inspection Point is named "Conveyor Belt 52H". The user ran inspection on the configuration named "Conveyor Built 52H *Camera 2*", so that's the name of the endpoint that displays on the **Deploy** page.

<img alt="le_config_deploy" />

<img alt="config_deploy_2" />


# Custom Processing
Source: https://landinglens.docs.landing.ai/landingedge/custom-processing



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

LandingEdge has a **Custom Processing** tool that automatically runs custom scripts before or after an image goes through inference. Custom Processing supports C# and Python scripts.

The two Custom Processing options are:

* **Image Processing**: LandingEdge runs the script **before** the image goes through inference.
* **Results Processing**: LandingEdge runs the script **after** the images goes through inference.

## Set Up Custom Processing

To add custom scripts to LandingEdge:

1. Click **Edit** next to **Image Processing** or **Results Processing**.
   <img alt="Custom Processing" />
2. Select **C#** or **Python** from the drop-down menu, depending on the type of script you have.
3. Replace the instructions in the large field with your custom script.
4. Click **Save**.
   <img alt="Save Script" />
5. The **Log Messages** field displays a success message if the script is accepted. If you received an error in this field, please check your script and try again.
   <img alt="Success Message" />
6. Click **Done**.

## Run Images Through Two Inspection Points

* **Script type**: Results processing
* **Model type**: Classification
* **Language**: Python

Use this script to run an image through a second Inspection Point if a certain class is predicted in the first Inspection point. The class predicted by the second Inspection Point can override the class predicted by the first Inspection Point.

This process is sometimes called "model-chaining" or "daisy-chaining", because you are programmatically chaining models together.

Here is the sample script. To see a use case, go to [Use Case for Running Images Through Two Inspection Points](./custom-processing#use-case-for-running-images-through-two-inspection-points).

```python theme={null}
def run(self):
   primary = self.Result.PrimaryResult
   self.Log(primary.Predictions.LabelName)
  
   if primary.Predictions.LabelName != "primary-trigger-class-name":
       # skip secondary inspection
       return

   # run secondary inspection
   secondary = self.RunOtherInspection("second-inspection-point-name", self.Image)
   secondaryResult = secondary.PrimaryResult.Predictions
   self.Log(secondaryResult.LabelName)

   if secondaryResult.LabelName == "secondary-inspection-class-name":
       self.Log("Overriding result")
       self.Result.SetDerivedResult(ClassificationResult("your-secondary-class-name", 1, secondaryResult.Score)
```

The table below describes the placeholders that you will need to update when using this script.

| Placeholder                       | Description                                                                                                                                                                                                                                                                                                    |
| --------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `primary-trigger-class-name`      | The name of the class that triggers the image to go through the second Inspection Point.<br />For example, if you want an image to go through a second Inspection Point if the class "Dog" is detected, replace `primary-trigger-class-name` with `Dog`.                                                       |
| `second-inspection-point-name`    | The name of the second Inspection Point.<br />For example, if the name of the second Inspection Point is called "puppy-inspection", replace `second-inspection-point-name` with `puppy-inspection`.                                                                                                            |
| `secondary-inspection-class-name` | The name of the predicted class in the second Inspection Point that triggers the "final" prediction to change.<br />For example, if you want the class "Puppy" to override a previous prediction if the second Inspection Point predicts "puppy", then replace `secondary-inspection-class-name` with `Puppy`. |
| `overridden-class-name`           | The name of the class that will be the "final" predicted class if the criteria in `secondary-inspection-class-name` is met.<br />For example, if you want the "final" predicted class to be "Puppy" if the other criteria is met, replace `overridden-class-name` with `Puppy`.                                |

### Use Case for Running Images through Two Inspection Points

Let's say you work for an automatic dog door company, and you want your model to detect dogs and puppies so that when a dog or puppy approaches the dog door, the door will automatically open. Your model has these classes: Not Dog, Dog, and Puppy. You can use the "daisy-chaining" script below to solve this use case.

This is how the script works:

* The image goes through the first Inspection Point.
* The model in that Inspection Point predicts a class.- If the prediction is "Not Dog", the image is not sent to a Second Inspection Point.
* If the prediction is "Dog", the image is sent to a second Inspection Point called "puppy-inspection" to check if the dog is a puppy.- If the second Inspection Point also predicts a dog, the class stays as "Dog".
* If the second Inspection Point predicts a puppy, the class is overridden to "Puppy".

Here is the Python script for this use case:

```python theme={null}
def run(self):
    primary = self.Result.PrimaryResult
    self.Log(primary.Predictions.LabelName)
    
    if primary.Predictions.LabelName != "Dog":
        # skip secondary inspection
        return

    # run secondary inspection
    secondary = self.RunOtherInspection("puppy-inspection", self.Image)
    secondaryResult = secondary.PrimaryResult.Predictions
    self.Log(secondaryResult.LabelName)

    if secondaryResult.LabelName == "Puppy":
        self.Log("Overriding result")
        self.Result.SetDerivedResult(ClassificationResult("Puppy", 1, secondaryResult.Score))
```

## Override the Class Name, Confidence Score, and Index

* **Script type**: Results processing
* **Model type**: Classification
* **Language**: Python

Use this script to override the class name and confidence score of a model's prediction. For example, use the script to override the final predictions based on the model's results and other logic you'd like to add.

Here is the sample script:

```python theme={null}
def run(self):
    newClass = "new-class"
    newScore = "number"
    newIndex = 1
    newResult = ClassificationResult(newClass, newIndex, newScore)
    self.Result.SetDerivedResult(newResult)
```

The table below describes the placeholders that you will need to update when using this script.

| Placeholder | Description                                                                                                                                                                                                      |
| ----------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `new-class` | The name of the class that will be the "final" predicted class.<br />For example, if the model predicted the class "Cat", but it should be "Dog", replace `new-class` with `Dog`.                                |
| `number`    | The confidence score that will be the "final" confidence score. This value must be a number between 0 and 1.<br />For example, if you want to change the confidence score to .876, replace `number` with `.876`. |

## Add Metadata to Images

<Info>The ability to add metadata to images through scripting is available in LandingEdge v2.3.93 and later.</Info>

* **Script type**: Results processing
* **Model type**: Any
* **Language**: Python

If you save images to LandingLens (by enabling [Upload Results to LandingLens](./manage-inspection-points#media-saving)), you can see the image metadata on the [Deploy](/historical-data) page (**Deploy** > **Self-Hosted Deployment** > **Inspection Point** > **open image**). This metadata is only accessible in LandingLens, and isn't embedded in the image.

You can run a script to customize the values for the following metadata

* Image ID
* Inspection Station ID
* Location ID

<img alt="script_metadata" />

Here is the sample script:

```python theme={null}
def run(self):
    self.Data.Metadata.ImageID = "1234"
    self.Data.Metadata.InspectionStationID = "Inspection Point A"
    self.Data.Metadata.LocationID = "Main Warehouse"
```

The table below describes the placeholders that you will need to update when using this script.

| Placeholder          | Description                             |
| -------------------- | --------------------------------------- |
| `1234`               | The value for the Image ID.             |
| `Inspection Point A` | The value for the Inspection Station ID |
| `Main Warehouse`     | The value for the Location ID.          |

## Skip Saving Certain Images

<Info>The ability to skip saving certain images through scripting is available in LandingEdge v2.4.89 and later.</Info>

* **Script type**: Results processing
* **Model type**: Any
* **Language**: C#

If you save images to LandingLens (by enabling [Upload Results to LandingLens](./manage-inspection-points#media-saving)), you can run a script to skip saving certain images.

Here is the sample script:

```csharp theme={null}
public void Run()
{
    Data.ForceSkipSaveImage = true; // will not save or upload this image+result
}
```

## Read Out Raw Scores from a Classification Model

<Info>The ability to read out raw scores through scripting is available in LandingEdge v2.5.10 and later.</Info>

* **Script type**: Results processing
* **Model type**: Classification
* **Language**: C#

This sample script allows you to read out the raw scores from a Classification model. This script also includes `AllClasses`, which is a Dictionary with the class index as the key. The `AllClasses` Dictionary provides access to all names and indices of all classes in the model, so class information can be retrieved with `AllClasses[index]`.

Here is the sample C# post-processing script for reading out the raw scores from a Classification model:

```csharp theme={null}
public void Run()
{
    if (Result.PrimaryResult is not ClassificationResult clf)
    {
        // not a classification result
        // this script is only applicable to classification, so exit the script
        return;
    }

    Log($"All classes in model: {string.Join(", ", AllClasses)}");
    Log($"Class scores for image: [{string.Join(", ", clf.Predictions.RawScores)}]");

    for (int i=0; i<AllClasses.Count; i++)
    {
        Log($"Class '{AllClasses[i].Name}' score = {clf.Predictions.RawScores[i]}");
    }    
}
```

<img alt="script_rawscores" />

## Return Class Name for Object Detection Models

* **Script type**: Results processing
* **Model type**: Object Detection
* **Language**: Python and C#

Let's say you are using LandingEdge to run inference with an Object Detection model and sending the results to a [Programmable Logic Controller (PLC)](./plc-workflow). You want LandingEdge to send the name of the predicted class, but that action is only supported for Classification models. LandingEdge doesn't directly support sending the class name for Object Detection models because there could be multiple objects and classes detected in each image. When it’s only possible for one object to be detected (like with Classification models), then the process is straightforward.

As a workaround, you can use the [C#](./custom-processing#c-script) and [Python](./custom-processing#python-script) scripts below to:

1. First, determine which box (the bounding box of the prediction around the object) has the highest confidence score.
2. Then, return the class name of the box with the highest confidence score.

The scripts can be customized to use different criteria to determine which class is sent.

### C# Script

Here is the sample C# script for returning the class name of the prediction with the highest confidence score:

```csharp theme={null}
public void Run()
{
    if (Result.PrimaryResult is not ObjectDetectionResult od)
    {
        // not an object detection result
        // this script is only applicable to object detection, so exit
        return;
    }

    Log($"Total number of boxes found: {od.Predictions.Count}");

    if (od.Predictions.Count == 0)
    {
        // no boxes, just return, but could also create a default response
        return;
    }

    // need to choose which class index to report from all the boxes
    // arbitrarily, let's pick the box with the highest score
    float maxScore = float.MinValue;
    string className = string.Empty;
    int classIndex = -1;

    foreach (var pred in od.Predictions)
    {
        if (pred.Value.Score > maxScore)
        {
            // this box is the highest so far, remember it
            maxScore = pred.Value.Score;
            className = pred.Value.LabelName;
            classIndex = pred.Value.LabelIndex;
        }
    }
    
    // now, create a derived classification result with the values from above
    // change 'true' in 'isOk: true' to 'false' if appropriate
    var newResult = new ClassificationResult(className, classIndex, maxScore, isOk: true);
    Result.SetDerivedResult(newResult);
}
```

### Python Script

Here is the sample Python script for returning the class name of the prediction with the highest confidence score:

```python theme={null}
def run(self):
    if not isinstance(self.Result.PrimaryResult, ObjectDetectionResult):
        # not an object detection result
        # this script is only applicable to object detection, so exit
        return

    od: ObjectDetectionResult = self.Result.PrimaryResult

    self.Log(f"Total number of boxes found: {od.Predictions.Count}")

    if od.Predictions.Count == 0:
        # no boxes, just return, but could also create a default response
        return

    # need to choose which class index to report from all the boxes
    # arbitrarily, let's pick the box with the highest score
    maxScore = -1
    className = ''
    classIndex = -1

    for _, box in od.Predictions:
        if box.Score > maxScore:
            # this box is the highest so far, remember it
            maxScore = box.Score
            className = box.LabelName
            classIndex = box.LabelIndex
    
    # now, create a derived classification result with the values from above
    # change 'True' in 'isOk=True' to 'False' if appropriate
    newResult = ClassificationResult(className, classIndex, maxScore, isOk=True)
    self.Result.SetDerivedResult(newResult)
```


# Docker Deploy
Source: https://landinglens.docs.landing.ai/landingedge/docker-deploy



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span> (see exceptions below)</td>
    </tr>
  </tbody>
</table>

You can deploy LandingLens models using Docker, which enables DevOps users to integrate the model inference programmatically.

The Docker approach is headless, which means that it has no user interface. This allows you to manage inference programmatically and scale deployments quickly.

After deploying the model, you can make inference calls using API commands or the [LandingLens Python library](https://github.com/landing-ai/landingai-python).

Here’s a quick summary of the benefits that the Docker deployment offers:

* Deployable in a private cloud environment or on any operating system
* Total API control (including remote access) for inference
* Can manage deployments programmatically
* Not limited to a certain amount of inferences per minute
* Can be used with or without a GPU
* All communication with the  server is via an HTTPS connection

<Info>Deploying LandingLens models with Docker is intended for developers who are familiar with Docker and programming languages. If that's not you, that's okay! In that case, we recommend that you explore our other [deployment options](/deployment-options).</Info>

<Info> Docker v2.8.8 and later does not require a deployment license. If you have an earlier version, please upgrade to the latest version.</Info>

<Info>Deploying Anomaly Detection models with Docker requires  Docker 2.11.1 or later.</Info>

## Deploy the Model Online or Offline

With our Docker approach, you can deploy the model **online** or **offline**.

If you deploy the model **online**, the model is downloaded directly from LandingLens, which requires an internet connection.

If you deploy the model **offline**, you first manually download the model from LandingLens (which does require an internet connection), and then programmatically upload it to the container (which doesn't require an internet connection).

Regardless of whether you run the model online or offline, inference is run locally.

## Requirements

Ensure that you meet all the requirements before installing and running the  Deploy Docker image:

* [Required applications](./docker-deploy#required-applications)
* [System support and requirements](./docker-deploy#system-support-and-requirements)
* [NVIDIA Jetson support](./docker-deploy#nvidia-jetson-support) (if using those devices)
* [GPU support](./docker-deploy#gpu-support) (if using those devices)

### Required Applications

Install the following applications and systems in order to install and run the  Deploy Docker image:

* [Python](https://www.python.org/downloads/)
* [Docker Engine](https://docs.docker.com/engine/): Install the correct version for your operating system. If you plan to use an Amazon instance, we recommend using Ubuntu AMI.
* [LandingLens Python Library](https://github.com/landing-ai/landingai-python): You will use the library to run inference.

### System Support and Requirements

| Item                                  | Requirement                                                                                                                                                                                                                                                     |
| ------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Supported Operating Systems           | Linux, macOS, Windows                                                                                                                                                                                                                                           |
| Memory                                | <ul><li>Minimum: 8 GB</li><li>Recommended: 16 GB or more</li></ul>                                                                                                                                                                                              |
| Supported Processors and Architecture | x86-64, ARM64<br />X86-64 includes, but is not limited to:<ul><li>Intel Core i5 (2013 Haswell or later)</li><li>AMD Ryzen (2017 Zen or later)</li></ul>ARM64 includes, but is not limited to:<ul><li>AWS Graviton2</li><li>Apple silicon (M1, M2, M3)</li></ul> |
| Internet Connection                   | Required to download the Docker image and model.<br />Not required to run inference.                                                                                                                                                                            |

### NVIDIA Jetson Support

NVIDIA Jetson devices are supported but not required. If you choose to use an NVIDIA Jetson device:

* **Minimum**: NVIDIA Jetson Orin Nano (or better/similar)
* **Recommended**: NVIDIA Jetson Orin AGX (or better/similar)

<Info>Docker might require you to run commands or download libraries specific to your NVIDIA device and driver version. We recommend reading the [NVIDIA](https://developer.nvidia.com/embedded/learn/tutorials/jetson-container) documentation to understand requirements and compatibility.</Info>

### GPU Support

<Info>For information about NVIDIA Jetson devices, go [here](#nvidia-jetson-support).</Info>

<Info>Docker might require you to run commands or download libraries specific to your NVIDIA device and driver version. We recommend reading the [Docker](https://docs.docker.com/engine/containers/resource_constraints/#gpu) and [NVIDIA](https://developer.nvidia.com/container-runtime) documentation to understand requirements and compatibility.</Info>

## Install the Image

To install the  Docker image, you will pull the image from Amazon Elastic Container Registry (Amazon ECR), a library of containerized applications. The image size is about 6GB. You can see all of the  "Deploy" images [here](https://gallery.ecr.aws/landing-ai/deploy).

You only need to install (pull) the image once. After you've downloaded the image, you're ready to launch an instance of it.

To pull the image, run this command:

```bash theme={null}
docker pull public.ecr.aws/landing-ai/deploy:latest
```

### Install the Image on Jetson Devices

We provide separate images for users on NVIDIA Jetson devices. To pull the image you need, run the command based on your JetPack version.

**For NVIDIA Jetson devices with JetPack 6.x:**

Go to the [LandingAI repository](https://gallery.ecr.aws/landing-ai/deploy) in Amazon ECR and download the most recent version with the `-jp6` suffix.

```bash theme={null}
docker pull public.ecr.aws/landing-ai/deploy:VERSION-jp6
```

**For NVIDIA Jetson devices with JetPack 5.x:**

<Info>The last version of  Docker that supports JetPack 5.x is v2.11.81. Later versions no longer support JetPack 5.x.</Info>

Go to the [LandingAI repository](https://gallery.ecr.aws/landing-ai/deploy) in Amazon ECR and download the most recent version with the `-jp5` suffix.

```bash theme={null}
docker pull public.ecr.aws/landing-ai/deploy:VERSION-jp5
```

**For NVIDIA Jetson devices with JetPack 4.x:**

<Info>The last version of  Docker that supports JetPack 4.x is v2.11.81. Later versions no longer support JetPack 4.x.</Info>

<Info>On  Docker v2.11.81 and earlier, the JetPack 4.x image does not support most Object Detection models. It only supports Object Detection models created with the **RtmDet-\[9M]** Model Size in [Custom Training](/custom-training).</Info>

Go to the [LandingAI repository](https://gallery.ecr.aws/landing-ai/deploy) in Amazon ECR and download the most recent version with the `-jp4` suffix.

```bash theme={null}
docker pull public.ecr.aws/landing-ai/deploy:VERSION-jp4
```

## Docker Deployment Quick-Start Guide

To run inference on a model after installing the  Docker image, go through this checklist:

1. Ensure you have a model in LandingLens that you want to run inference on. (New to LandingLens? Learn how to train a model [here](/train-models).)
2. [Activate the project](/activate-projects) that has the model you want to run inference with. You must activate a project in LandingLens first, regardless if you will run the model online or offline.
3. If you want to run the model **offline**, [download the model](/download-models).
4. Locate the [Model ID](./docker-deploy#locate-your-model-id) for the model you want to run inference on.
5. Locate your LandingLens [API key](./docker-deploy#locate-your-landinglens-api-key). (This isn't applicable if you're using . Instead, you'll use a key pair generated when installing .)
6. If you want to run the model **online**, run the [run-model-id](./docker-deploy#deploy-the-model-online) command. (If you're using , include specific Snowflake [flags](./docker-deploy#deploy-the-model-online-for-landinglens-on-snowflake).)
7. If you want to run the model **offline**, run the [run-local-model](./docker-deploy#deploy-the-model-offline) command.
8. [Run inference with the LandingLens Python library](./docker-deploy#run-inference-with-the-landing-ai-python-sdk).

### Locate Your Model ID

The Model ID is included in the command to deploy the model via Docker. The Model ID tells the application which model to download from LandingLens.

On the **Models** page, click the **Actions** (...) icon and select **Copy Model ID**. For details, go to [Get the Model ID for Docker](/models-page#get-the-model-id-for-docker).

<img alt="copy-bundle-id" />

### Locate Your LandingLens API Key

<Info>This is not applicable when using .</Info>
LandingLens uses API keys to authenticate access to the system. You will use an API Key in the command to download your computer vision model from LandingLens.

LandingLens API keys are managed on the **API Keys** page. To learn how to locate your LandingLens API key, go to [Retrieve API Key](/api-key#retrieve-api-key).

<img alt="api_new" />

## Deploy the Model Online

<Info>If using , follow the instructions in [Deploy the Model Online (for LandingLens on Snowflake)](#deploy-the-model-online-for-landinglens-on-snowflake).</Info>

If you want to deploy the model online, run the `run-model-id` command to launch a container with the model.

By default, the inference endpoint port is 8000. In the code snippet below, the `port` flag (`-p`) sets the ports for the host and the container. The port on the left is the host port, and the port on the right is the container port.

To run the `run-model-id` command:

```bash theme={null}
docker run \
	-p 8000:8000 \
	--rm public.ecr.aws/landing-ai/deploy:latest run-model-id \
	--apikey API_KEY \
	--model MODEL_ID
```

When you run the command, the Deploy application downloads your model from LandingLens. When it’s done, this message displays:

```bash theme={null}
 [INF] Model loading status: [Ready]
```

### Examples

Deploy the model when you have only an API Key (and not an API Key *and* API Secret):

```bash theme={null}
docker run \
	-p 8000:8000 \
	--rm public.ecr.aws/landing-ai/deploy:latest run-model-id \
	--apikey API_KEY \
	--model MODEL_ID
```

Deploy the model when you have an API Key *and* an API Secret:

```bash theme={null}
docker run \
	-p 8000:8000 \
	--rm public.ecr.aws/landing-ai/deploy:latest run-model-id \
	--apikey API_KEY \
	--apisecret API_SECRET \
	--model MODEL_ID
```

Deploy the model. When you send images for inference, [save those images and the predictions](/historical-data) to the corresponding project in LandingLens:

```bash theme={null}
docker run \
	-p 8000:8000 \
	--rm public.ecr.aws/landing-ai/deploy:latest run-model-id \
	--apikey API_KEY \
	--model MODEL_ID \
	--upload
```

Deploy the model. When you deploy a model, the name of the device displays on the Deploy page in LandingLens. Set a device name:

```bash theme={null}
docker run \
	-p 8000:8000 \
	--rm public.ecr.aws/landing-ai/deploy:latest run-model-id \
	--apikey API_KEY \
	--model MODEL_ID \
	--name "my edge device" \
	--upload
```

### Flags

| Flag                | Description                                                                                                                                                                                                                                                                              |
| ------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `-k`, `--apikey`    | Required. Set an API Key for your LandingLens organization. Can also set through the `'LANDING_API_KEY'` environment variable.<sup>1</sup>                                                                                                                                               |
| `-s`, `--apisecret` | If you’re using a “legacy” API Key and API Secret pair, set the API Secret. Can also set through the `'LANDING_API_SECRET'` environment variable.<sup>1</sup>                                                                                                                            |
| `-m`, `--model`     | Required. Set the Model ID of the model you want to load. To locate your Model ID, go to [Locate Your Model ID](./docker-deploy#locate-your-model-id). Can also set through the `'MODEL_ID'` environment variable.                                                                       |
| `-p`, `--port`      | The port number to use for communicating with the deployed model via API. Can also set through the `'PORT'` environment variable.<br />Default: `8000`.                                                                                                                                  |
| `-e`, `--external`  | Allow external hosts to access the API. Can also set through the `'ALLOW_EXTERNAL'` environment variable.<br />If running in a container, the default is `true`. Otherwise, the default is `false`.                                                                                      |
| `-u`, `--upload`    | When you send images for inference, save those images and the predictions to the corresponding project in LandingLens. Can also set through the `'UPLOAD_RESULTS'` environment variable.<br />Default: `false`.                                                                          |
| `-g`, `--gpus`      | Select the GPUs you want to use to run inference. Include a space-separated list of the GPU indices. If you select multiple GPUs, the system will balance the load between the processors. Can also set through the `'GPUS'` environment variable.<br />Default: use all GPUs available. |
| `-n`, `--name`      | When you deploy a model, the name of the device displays on the Deploy page in LandingLens. Use this flag to set the device name. Can also set through the `'DEVICE_NAME'` environment variable.<br />If unspecified the default is `'LE-{hostname}'`.                                   |
| `--help`            | Display more information about the command.                                                                                                                                                                                                                                              |
| `--version`         | Display version information.                                                                                                                                                                                                                                                             |

<Info>1. Up until June 30, 2023, LandingLens required both an API Key and API Secret to be used to run inference. As of that date, LandingLens only generates API Keys (and not API Key and API Secret pairs). For more information, go to [API Keys](/api-key).</Info>

## Deploy the Model Online (for LandingLens on Snowflake)

If you're using  and want to deploy the model online, run the `run-model-id` command with specific Snowflake [flags](./docker-deploy#flags1) to launch a container with the model.

By default, the inference endpoint port is 8000. In the code snippet below, the `port` flag (`-p`) sets the ports for the host and the container. The port on the left is the host port, and the port on the right is the container port.

To run the `run-model-id` command for :

```bash theme={null}
docker run \
	-v /Users/user/keys:/keys \
	-p 8000:8000 \
	 public.ecr.aws/landing-ai/deploy:latest run-model-id \
	--model MODEL_ID \
	--use-snowflake \
	--snowflake-account SNOWFLAKE_LOCATOR \
	--snowflake-user NAME \
	--snowflake-private-key-path /keys/private-key.p8 \
	--snowflake-app-url https://example.snowflakecomputing.app/ 
```

When you run the command, the Deploy application downloads your model from LandingLens. When it’s done, this message displays:

```bash theme={null}
 [INF] Model loading status: [Ready]
```

### Flags

| Flag                           | Description                                                                                                                                                                                                                                                                                                                                                                                 |
| ------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `--use-snowflake`              | Required if using . Can also set through the `'USE_SNOWFLAKE'` environment variable.<br />Default: `false`.                                                                                                                                                                                                                                                                                 |
| `--snowflake-account`          | Required if using . Enter your Snowflake account [locator](https://docs.snowflake.com/en/user-guide/admin-account-identifier#format-2-account-locator-in-a-region). To learn how to get your locator, go to the [Snowflake documentation](https://docs.snowflake.com/en/sql-reference/functions/current_account).<br />Can also set through the `'SNOWFLAKE_ACCOUNT'` environment variable. |
| `--snowflake-user`             | Required if using . Enter your Snowflake username. This is the `NAME` property in Snowflake.<br />Can also set through the `'SNOWFLAKE_USER'` environment variable.                                                                                                                                                                                                                         |
| `--snowflake-private-key-path` | Required if using . Enter the path to your RSA private key, which is used for authenticating with Snowflake.<br />Can also set through the `'SNOWFLAKE_PRIVATE_KEY_PATH'` environment variable.                                                                                                                                                                                             |
| `--snowflake-app-url`          | Required if using . Enter the fully qualified domain of your instance of . For example, the URL could be `https://example.snowflakecomputing.app/`.<br />Can also set through the `'SNOWFLAKE_APP_URL'` environment variable.                                                                                                                                                               |
| `--snowflake-privatelink`      | Allow the use of AWS PrivateLink with Snowflake. Can also set through the `'SNOWFLAKE_USE_PRIVATELINK'` environment variable.<br />Default: `false`.                                                                                                                                                                                                                                        |
| `-m`, `--model`                | Required. Set the Model ID of the model you want to load. To locate your Model ID, go to [Locate Your Model ID](./docker-deploy#locate-your-model-id). Can also set through the `'MODEL_ID'` environment variable.                                                                                                                                                                          |
| `-p`, `--port`                 | The port number to use for communicating with the deployed model via API. Can also set through the `'PORT'` environment variable.<br />Default: `8000`.                                                                                                                                                                                                                                     |
| `-e`, `--external`             | Allow external hosts to access the API. Can also set through the `'ALLOW_EXTERNAL'` environment variable.<br />If running in a container, the default is `true`. Otherwise, the default is `false`.                                                                                                                                                                                         |
| `-u`, `--upload`               | When you send images for inference, save those images and the predictions to the corresponding project in LandingLens. Can also set through the `'UPLOAD_RESULTS'` environment variable.<br />Default: `false`.                                                                                                                                                                             |
| `-g`, `--gpus`                 | Select the GPUs you want to use to run inference. Include a space-separated list of the GPU indices. If you select multiple GPUs, the system will balance the load between the processors. Can also set through the `'GPUS'` environment variable.<br />Default: use all GPUs available.                                                                                                    |
| `-n`, `--name`                 | When you deploy a model, the name of the device displays on the Deploy page in LandingLens. Use this flag to set the device name. Can also set through the `'DEVICE_NAME'` environment variable.<br />If unspecified the default is `'LE-{hostname}'`.                                                                                                                                      |
| `--help`                       | Display more information about the command.                                                                                                                                                                                                                                                                                                                                                 |
| `--version`                    | Display version information.                                                                                                                                                                                                                                                                                                                                                                |

## Deploy the Model Offline

If you want to deploy the model offline, run the `run-local-model` command. Running the model offline is helpful if your system doesn't have internet access or has limited bandwidth (which could make it difficult to download the image from Docker). Also, running the model offline reduces startup time, because you don't have to wait to download the file.

When running this command, include the [mount volume](https://docs.docker.com/reference/cli/docker/container/run/#volume) (`-v`) flag from Docker so that it can access the file you downloaded.

### Examples

Deploy the model:

```bash theme={null}
docker run -v /Users/user/Downloads:/folder public.ecr.aws/landing-ai/deploy:latest run-local-model --model /folder/model-bundle.zip
```

Deploy the model. When you send images for inference, save those images and the predictions to the corresponding project in LandingLens:

```bash theme={null}
docker run -v /Users/user/Downloads:/folder public.ecr.aws/landing-ai/deploy:latest run-local-model --model /folder/model-bundle.zip --upload
```

Deploy the model. When you deploy a model, the name of the device displays on the Deploy page in LandingLens. Set a device name:

```bash theme={null}
docker run -v /Users/user/Downloads:/folder public.ecr.aws/landing-ai/deploy:latest run-local-model --model /folder/model-bundle.zip --name "my edge device" --upload
```

#### Flags

| Flag               | Description                                                                                                                                                                                                                                                                              |
| ------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `-m`, `--model`    | Required. The model bundle to load. This will be a zip file. Can also set through the `'MODEL_PATH'` environment variable.                                                                                                                                                               |
| `-p`, `--port`     | The port number to use for communicating with the deployed model via API. Can also set through the `'PORT'` environment variable.<br />Default: `8000`.                                                                                                                                  |
| `-e`, `--external` | Allow external hosts to access the API. Can also set through the `'ALLOW_EXTERNAL'` environment variable.<br />If running in a container, the default is `true`. Otherwise, the default is `false`.                                                                                      |
| `-u`, `--upload`   | When you send images for inference, save those images and the predictions to the corresponding project in LandingLens. Can also set through the `'UPLOAD_RESULTS'` environment variable.<br />Default: `false`.                                                                          |
| `-g`, `--gpus`     | Select the GPUs you want to use to run inference. Include a space-separated list of the GPU indices. If you select multiple GPUs, the system will balance the load between the processors. Can also set through the `'GPUS'` environment variable.<br />Default: use all GPUs available. |
| `-n`, `--name`     | When you deploy a model, the name of the device displays on the Deploy page in LandingLens. Use this flag to set the device name. Can also set through the `'DEVICE_NAME'` environment variable.<br />If unspecified the default is `'LE-{hostname}'`.                                   |
| `--help`           | Display more information about the command.                                                                                                                                                                                                                                              |
| `--version`        | Display version information.                                                                                                                                                                                                                                                             |

## Make Inference Calls with API Commands

Once the container with the model is ready, you can run inference with the model by using API commands.

## Run Inference with the LandingLens Python Library

Once the container with the deployed model is ready, you can run inference by making calls to the container using the [LandingLens Python library](https://github.com/landing-ai/landingai-python).

If your client code (in other words, your Python code) is on the same machine you’re running inference on, you can also use `localhost` instead of the IP address.

The following example shows how to run inference within an instance hosted on 192.168.1.12, port 8000. For more examples, see our [Python library](https://github.com/landing-ai/landingai-python/tree/main#landinglens-python-sdk).

```python theme={null}
from landingai.predict import EdgePredictor
import PIL.Image

predictor = EdgePredictor(host="192.168.1.12", port=8000)
img = PIL.Image.open("/Users/username/Downloads/test.png")
predictions = predictor.predict(img)
```

## Power Inference with GPUs

By default, the Docker deployment doesn’t use any GPUs in your system. However, you can configure the deployment to use some or all of your GPUs. See the list of supported GPUs [here](./docker-deploy#gpu-support).

In this section, we’ll give you the basics about how to enable GPUs to power inference. However, Docker might require you to run commands or download libraries specific to your NVIDIA device and driver version. We recommend reading the [Docker](https://docs.docker.com/config/containers/resource_constraints/#gpu) and [NVIDIA](https://developer.nvidia.com/nvidia-container-runtime) documentation to understand requirements and compatibility.

To use all GPUs in your system to power inference, include the `--gpus all` flag as part of the docker command. For example:

```bash theme={null}
docker run --gpus all -p 8000:8000 --rm -e public.ecr.aws/landing-ai/deploy:latest run-model-id --apikey API_KEY --model MODEL_ID
```

To use only specific GPUs in your system to power inference, include the `--gpus` flag and enter the indices of the GPUs you want to use as a comma-separated list. For example, in the snippet below, the deployment will use the GPUs with index 0 and index 2:

```bash theme={null}
docker run --rm --gpus '"device=0,2"' -p 8000:8000 -e public.ecr.aws/landing-ai/deploy:latest run-model-id --apikey API_KEY --model MODEL_ID
```

## Deploy with Kubernetes

You can deploy the  Deploy image with Kubernetes and monitor the system with our [status APIs](./docker-deploy#web-apis-in-swagger).

Here is an example Kubernetes Pod YAML deployment file for the  Deploy image:

```yaml theme={null}
apiVersion: v1
kind: Pod
metadata:
  name: landingai-deploy
  namespace: default
  labels:
    app.kubernetes.io/name: landingai-deploy
    app: landingai-deploy
spec:
  containers:
  - name: landingai-deploy
    image: public.ecr.aws/landing-ai/deploy:latest
    args: ["run-model-id", "-m", "YOUR_MODEL_ID"]
    imagePullPolicy: IfNotPresent
    env:
      - name: LANDING_API_KEY
        value: "YOUR_API_KEY"
    ports:
      - containerPort: 8000
    resources:
      requests:
        memory: 2G
        cpu: 2
      limits:
        memory: 4G
        cpu: 5
    startupProbe:
      httpGet:
        port: 8000
        path: /status
    livenessProbe:
      httpGet:
        port: 8000
        path: /live
      initialDelaySeconds: 5
      periodSeconds: 5
    readinessProbe:
      httpGet:
        port: 8000
        path: /ready
      initialDelaySeconds: 5
      periodSeconds: 5
```

## Web APIs in Swagger

To access the web APIs for the  Docker deployment solution in Swagger, go to `http://localhost:[port]`, where `[port]` is the port you’re using to communicate with the Dockerized application.

Use the `/status`, `/ready`, and `/live` endpoints to monitor the status when using Kubernetes or another orchestration system.

Use the `/images` endpoint to run inference.

You can use these web APIs to programmatically start or monitor inference.

<img alt="docker_swagger" />

### /status

The `/status` endpoint always returns `200`.

### /ready

The `/ready `endpoint indicates if the model is ready to receive inference calls. It returns `200` if the model is loaded. Otherwise, it returns `503`, which indicates that either the model hasn't loaded yet or the model failed to load.

### /live

The `/live` endpoint returns `200` if the model is loading or loaded. Otherwise, it returns `503`, which indicates that the container is dead and should be killed by the orchestrator (such as Kubernetes).

### /images

Use the `/images` endpoint to run inference. Results are returned in JSON.

<Info>The`/api/v1/images`endpoint is provided for compatibility with an older version of the  Docker image. It is supported, but the JSON results are formatted differently.</Info>

## Troubleshooting: User Declined Directory Sharing

**Scenario**

You receive the following error message when running the `run-local-model` command:

```bash theme={null}
Error response from daemon: user declined directory sharing [directory path].
```

**Solution**

This error indicates that the  Deployment application does not have permission to access the directory you included in the command. Add the directory to the **File Sharing** list in Docker Desktop. The way to do this depends on your operating system. See the instructions for your system: [Mac](https://docs.docker.com/desktop/settings/mac/#file-sharing), [Windows](https://docs.docker.com/desktop/settings/windows/#file-sharing), and [Linux](https://docs.docker.com/desktop/settings/linux/#file-sharing).


# Download and Install LandingEdge
Source: https://landinglens.docs.landing.ai/landingedge/download-and-install-landingedge



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

<iframe title="YouTube video player" />

<Info>LandingEdge v2.8.8 and later does not require a deployment license. If you have an earlier version, please upgrade to the latest version.</Info>

## Download and Install LandingEdge on Windows

To download and install LandingEdge on Windows:

1. Open LandingLens.
2. Open any project.
3. Click **Deploy**.
4. If you haven't deployed a model in the project yet, click **Download LandingEdge**.
   <img alt="download_LE_2024" />
5. If you've already deployed a model in the project, click **LandingEdge**.
   <img alt="LandingEdge" />
6. Click **Download for Windows**.
   <img alt="Download_LE_Windows" />
7. The LandingEdge installer automatically downloads.
8. After the download completes, open the LandingEdge installer.
   <img alt="Open Installer" />
9. Follow the prompts to install LandingEdge.

## Download and Install LandingEdge on Linux

To download and install LandingEdge on Linux:

1. Open LandingLens.
2. Open any project.
3. If you haven't deployed a model in the project yet, click **Download LandingEdge**.
   <img alt="download_LE_2024" />
4. If you've already deployed a model in the project, click **LandingEdge**.
   <img alt="LandingEdge" />
5. Click **Download for Linux**.
   <img alt="Download_LE_Linux" />
6. The LandingEdge installer automatically downloads.
7. To extract the LandingEdge installer to the target installation directory, run this command in the command line (replace `your_installation_dir` with your directory):
   ```bash theme={null}
   sh LandingEdge.run --target your_installation_dir
   ```
8. To run the LandingEdge application, run this command in the command line:
   ```bash theme={null}
   landing-edge
   ```

<Info>Downloading and installing LandingEdge doesn't create a container.</Info>


# GPUs and LandingEdge
Source: https://landinglens.docs.landing.ai/landingedge/gpus-and-landingedge



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

If you have a graphics processing unit (GPU), LandingEdge will use it to run faster. In LandingEdge v2.6.45 and later, you can also assign an Inspection Point to run on one or more specific GPUs. If you allow the Inspection Point to use multiple GPUs, the system will balance the load between the processors.

For more information about supported GPUs, go to [GPU Support](./landingedge-specifications-sheet#gpu-support).

<iframe title="YouTube video player" />

## Assign Specific GPUs to an Inspection Point

To assign specific GPUs to an Inspection Point:

1. Create an [Inspection Point](./manage-inspection-points).
2. If LandingEdge detects one or more [supported GPU](./landingedge-specifications-sheet#gpu-support), the **Accelerator** drop-down menu displays in the **Model** section. Select one of the following:
   * **None (CPU)**: Select if you don't want the Inspection Point to use a GPU. LandingEdge will use your computer's CPU (central processing unit) instead.
   * **NVIDIA GPU**: Select if you have a want to assign GPUs to the Inspection Point. If LandingLens doesn't detect a GPU, it will use your computer's CPU instead.
     <img alt="le_accelerartor_1" />
3. If LandingEdge detects multiple GPUs, select the checkbox for the GPUs you want the Inspection Point to use. If you don't select any GPUs, LandingEdge will pick the first one in the list.
   <img alt="le_pick_gpus_2" />
   <Info>Hover over a GPU to see a tooltip with the GPU identifiers. This is helpful if you have multiple GPUs that are the same model and you want to tell them apart.<br /><br /><img alt="le_pick_gpus_2" /></Info>
4. Finish setting up the Inspection Point.

## If You Change the GPU Selection

When you select a GPU, the model you selected is loaded onto that GPU. If you change the selected GPU, click **Reload Model** so that the model is loaded onto the new GPU.

<img alt="le_reload_model" />


# GenICam and GigE Vision Cameras
Source: https://landinglens.docs.landing.ai/landingedge/industrial-cameras



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

You can run inference on images uploaded from [GenICam-compliant](https://www.emva.org/standards-technology/genicam/) and GigE Vision industrial cameras to LandingEdge.

<Info>If using a PLC (Programmable Logic Controller), you can configure the PLC to trigger image capture. To learn how to set up a PLC with LandingEdge, go to [PLC Workflow](./plc-workflow).</Info>

## Compare GenICam and GigE Vision Functionality in LandingEdge

When setting up an Inspection Point in LandingEdge, you use the [Image Source](./manage-inspection-points#image-source) setting to select what type of device will capture images. If using an industrial camera, you can select to connect the camera using either the **GenICam** or **GigE Vision** source.

The following table explains how the connection and functionality are different between these two image sources.

| **Feature**                                                                      | GenICam                                                                            | GigE Vision<br /> |
| -------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------- | ----------------- |
| Method or standard for connecting the camera to the computer running LandingEdge | Various methods, including USB 3.0 cables, CoaXPress, Camera Link, GigE (Ethernet) | GigE (Ethernet)   |
| Capture images from multiple cameras simultaneously                              | ✖                                                                                  | ✓                 |
| Requires a [GenTL Producer](./industrial-cameras#gentl-producer)                 | ✓                                                                                  | ✖                 |

## GenTL Producer

If you select **GenICam** as your [Image Source](./manage-inspection-points#image-source) in LandingEdge, you must install a GenTL Producer in order for LandingEdge to communicate with the camera. A GenTL Producer is the transport layer interface that enables the camera and LandingEdge to communicate with each other.

The GenTL Producer is often included as part of your camera manufacturer's SDK, like the Basler Pylon SDK or Allied Vision Vimba SDK. If you're having trouble finding the GenTL Producer for your camera, try the SDK for your manufacturer.

## GigE Vision Camera Requirements

If you select **GigE Vision** as your [Image Source](./manage-inspection-points#image-source) in LandingEdge, LandingEdge doesn't require you to use third-party software.

However, if LandingEdge doesn’t recognize the GigE Vision camera, you may need to set the IP address and subnet mask for the camera using the software from the camera manufacturer (or a third-party software).

## Set Up LandingEdge to Use GenICam or GigE Vision Cameras

<Info>You can set up multiple *configurations* for each Inspection Point.</Info>

1. Create an Inspection Point.
2. Select either **GigEVision Camera** or **GenICam** from the **Image Source** drop-down menu.
   <img alt="GenICam_1" />
3. Click **Select**.
   <img alt="GenICam_2" />
4. All the cameras that LandingEdge detects display in a pop-up window. Select your camera and click **Select**.
   <img alt="GenICam_3" />
5. You can customize image capture settings, like by applying a crop to images. The available settings depend on your camera. If you want to customize these settings:1. Click **Add New Setting**.
   <img alt="GenICam_4" />
6. Select and configure the settings you want.
   <img alt="GenICam_5" />
7. Select your [Inspection Start](./manage-inspection-points#inspection-start) method. (If using a PLC with the camera, ensure that you understand the [PLC Workflow](./plc-workflow).)
8. Set up the [Cloud Connection and Model](./manage-inspection-points#cloud-connection-and-model-connect-to-a-landinglens-model)settings.
9. Skip the **Communication** section.
10. (Optional) Set up [Image Saving](./manage-inspection-points#image-saving) settings.
11. (Optional) Set up [Other Settings](./manage-inspection-points#other-settings) settings.
12. (Optional) Set up [Custom Processing](./custom-processing).
13. Click **Save Configuration**.

## Setup Considerations

This section describes certain functionality to keep in mind when setting up cameras with LandingEdge and other applications.

### You Can Use the Same Camera for Multiple Inspection Points

You can use the same camera for multiple Inspection Points at once in LandingEdge. For example, you can use GenICam A in two Inspection Points.

### A Camera Can Connect via GenICam or GigE Vision, But Not as Both at the Same Time

When setting up an Inspection Point in LandingEdge, you select the source of image capture (see [Image Source](./manage-inspection-points#image-source)). Some cameras can be connected using either the **GenICam** or **GigE Vision** source. If using a specific camera in multiple Inspection Points, you must select the same Image Source for the camera in all Inspection Points.

For example, let's say you want to use GenICam A in two Inspection Points. You can connect to it as a GenICam in both, or a GigE Vision camera in both. You can't connect the camera as a GenICam in one, and as a GigE Vision camera in the other.

### Only One Application Can Use a Camera at a Time

Only one application can use a specific GenICam or GigE Vision camera at a time. For example, if a manufacturing software is using a specific camera, you must disconnect the camera from that application before using it with LandingEdge.


# Run Inference with Web APIs
Source: https://landinglens.docs.landing.ai/landingedge/landingedge-apis



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

There are several ways to send images for inference in LandingEdge. This section explains how to use web APIs to upload images to your model for inference.

With this method, you upload and receive results programmatically. Therefore, this method requires proficiency with a modern programming language. We’ve provided Python examples in this article.

## Set Up Inspection Points for Images Sent via API

<Info>You can set up multiple *configurations* for each Inspection Point.</Info>

To set up Inspection Points to run inference on images sent via API, follow the instructions below:

1. Create an Inspection Point.
2. Select **Web API** from the **Image Source** drop-down menu.
3. Enter the port that you will use to send images to LandingEdge in the **Port** field.LandingEdge will monitor this port to receive images from your API call. The supported port number range is 7000 to 8000. If setting up multiple Inspection Points, use a different port for each Inspection Point.
4. If you want other devices (different IP addresses) on your network to be able to send images to the web API endpoint, select the **Allow External Access** checkbox.
   <img alt="le_webapi_1" />
5. Verify that **Self** is selected from the **Inspection Start** drop-down menu. This option means that sending an image via web API will trigger the inspection process to start. (This is the only option when using the web API method.)
   <img alt="le_webapi_2" />
6. Set up the [Cloud Connection and Model](./manage-inspection-points#cloud-connection-and-model-connect-to-a-landinglens-model)settings.
   <img alt="le_webapi_3" />
7. Skip the **Communication** section.
8. (Optional) Set up [Image Saving](./manage-inspection-points#image-saving) settings.
9. (Optional) Set up [Other Settings](./manage-inspection-points#other-settings) settings.
10. (Optional) Set up [Custom Processing](./custom-processing).

## Web API Documentation

To access the LandingEdge web APIs in Swagger, first ensure that the Inspection Point is running. Then go to `http://localhost:[port]/docs`, where `[port]` is the number you entered in the **Port** field when setting up the Inspection Point. For example, if you entered 7054 as your port number, then you would go to `http://localhost:7054/docs`.

<img alt="le_webapi_port" />

<img alt="le_webapi_swagger" />

## Web API Endpoints

The Web API provides the following possible endpoints you can use. All endpoints return the predictions as JSON.

* /images
* /RGB24mmf

### Example: /Images Endpoint

The following script shows how to use the `/images` endpoint to run inference on images that are already on your device.

```python theme={null}
import json
from mimetypes import guess_type
from pathlib import Path
from typing import Any, Union

import requests


def infer(filename: Union[Path, str], port: int) -> Any:
    """
    Run inference on an image using the /images endpoint
    :param filename: path to the image file
    :param port: port number from LandingEdge Web API configuration
    :return: object representing the inference results
    """
    # LandingEdge app url construction
    app_url = f"http://127.0.0.1:{port}/images"

    # Send the request
    with open(Path(filename).resolve(), "rb") as f:
        files = [("file", (Path(filename).name, f, guess_type(filename)))]
        response = requests.post(
            app_url,
            files=files)

    return json.loads(response.text)
```

### Example: /RGB24mmf Endpoint

<Info>The /RGB24mmf endpoint is only available on Windows.</Info>
When you use the **/RGB24mmf** endpoint, the API uses a local memory-mapped file (MMF) to transfer images, which is faster than sending a copy of the image.

The RGB24mmf API requires images to be on the same system that you are calling APIs from. If the images are on a separate system, you cannot call this API (even if the **Allow External Access** setting is enabled). Use this API if your images are already in the device's memory.

The following script shows how to use the `/RGB24mmf` endpoint to run inference on images stored in your device's memory.

```python theme={null}
import json
import mmap
import uuid
from typing import Any

import requests
from nptyping import ndarray


def infer(image: ndarray, port: int) -> Any:
    """
    Run inference on an image using the /RGB24mmf endpoint
    :param image: numpy array representing the image. Must be RGB ordering
    :param port: port number from LandingEdge Web API configuration
    :return: object representing the inference results
    """
    # LandingEdge app url construction
    windows_app_url = f"http://127.0.0.1:{port}/RGB24mmf"

    # retrieve information about the image
    height, width, _ = image.shape

    # Send the request
    tag_name = str(uuid.uuid4())
    with mmap.mmap(-1, height * width * 3, tagname=tag_name) as mm:
        mm.write(image.tobytes())
        response = requests.post(
            windows_app_url,
            files={
                "mmf": (None, tag_name),
                "height": (None, height),
                "width": (None, width),
            },
        )

        return json.loads(response.text)
```

## Example: Use the LandingLens Python Library

The following script shows how to use the LandingLens Python library to run inference on images already on your device. For more information, see the [LandingLens Python library](https://github.com/landing-ai/landingai-python).

```python theme={null}
from landingai.predict import EdgePredictor
import PIL.Image

predictor = EdgePredictor(host="127.0.0.1", port=8000)
img = PIL.Image.open("/Users/Username/Downloads/test.png")
predictions = predictor.predict(img)
```

## Example: cURL Request Example

The following code snippet shows how you can use the web APIs to send the image for inference from the command line using a cURL command.

```bash theme={null}
curl -X 'POST' \
  'http://localhost:<webAPI port entered in configuration>/images' \
  -H 'accept: application/json' \
  -H 'Content-Type: multipart/form-data' \
  -F 'file=@sample.jpg;type=image/jpeg'
```


# LandingEdge Overview
Source: https://landinglens.docs.landing.ai/landingedge/landingedge-overview



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

<iframe />

<Info>LandingEdge doesn't deploy  models. The only deployment option for  is [Cloud Deployment](/cloud-deployment).</Info>

<Info>LandingEdge is not compatible with smart cameras.</Info>

<Info>Deploying Anomaly Detection models with LandingEdge requires LandingEdge v2.11.78 or later.</Info>

## Overview

LandingEdge is an all-in-one application for end-to-end deployment. This application can connect to a camera, run inference, and drive continuous learning back to LandingLens. Let's take a look at how it works.

After you are happy with the results of your trained model, you can deploy it to LandingEdge to run inference. **Inference** is the process of showing images to a model that the model has never seen before.

LandingEdge retrieves images from a GenICam camera, a folder on your computer, or through an API call. Images can be saved to a folder and sent to LandingLens for continuous learning. **Continuous learning** is the process of regularly improving your model. To improve your model, you can save inference images and send them back to LandingLens to retrain your model. By continuously improving your model, you can have better results.

For example, let's say you previously trained a model for self-driving cars, and your model learned to detect people, other cars, and dogs. After you deploy your model, imagine that the cameras of the self-driving cars snapped images of deer and moose. You can send these images back to LandingLens so the model can learn to detect deer and moose.

LandingEdge can also be used as a standalone inference engine without the need for any hardware connections. This is achieved by API integration.

<img alt="LandingEdge General Workflow" />

## LandingEdge Features

* Runs on Windows and Linux
* Runs locally, and inference runs on your Windows or Linux computer
* Does not require the internet
* Can retrieve images from a USB, GenICam, input folder, or API call
* Can communicate with PLCs (programmable logic controllers)
* Can connect and send images to LandingLens for Continuous Learning


# LandingEdge Release Notes
Source: https://landinglens.docs.landing.ai/landingedge/landingedge-release-notes



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

<Update label="May 7, 2026">
  ## Expanded GPU Support (v2.12.74)

  This version includes several significant updates and bug fixes:

  * Adds GPU support up through Blackwell architecture cards, including RTX PRO 6000 Blackwell. For the full list of supported GPUs, go to [GPU Support](./docker-deploy#gpu-support).
  * Updates the included Python scripting environment in LandingEdge from 3.8 to 3.12. Python 3.8 has reached end of life.
  * Removes Python from the Docker images.
  * Removes support for [Classic Flow](../classic-flow) models, as previously announced.

  ## Notes for GenICam Users

  If using GenICam, you may need to re-select your camera in the Inspection Point configuration after upgrading. For more information, go to [GenICam and GigE Vision Cameras](./industrial-cameras).

  If you use GenICam and don't need the new GPU support, we recommend staying on v2.11.81. If you encounter issues with GenICam after upgrading, contact [support@landing.ai](mailto:support@landing.ai).
</Update>

<Update label="February 2, 2026">
  ## Fixed Segmentation Rendering Issue (v2.11.81)

  Under certain conditions the shown segmentation mask was offset by a few pixels.

  ## Last Version to Support NVIDIA JetPack 4.x and 5.x

  This is the last version of  Docker that supports NVIDIA JetPack 4.x and 5.x. Later versions no longer support those JetPack versions.
</Update>

<Update label="May 6, 2025">
  ## Add Embed-Optimized Model Support (v2.11.79)

  This version adds support for the new Embed-Optimized models:

  * For Object Detection: ODEmbedded-\[23M]
  * For Classification: ConvNextEmbedded-\[16M]

  This version also adds support for the latest Anomaly Detection model and 16-bit input images.
</Update>

<Update label="December 19, 2024">
  ## Expanded PLC Options (v2.10.31)

  When setting up communication between LandingEdge and a Programmable Logic Controller (PLC), you can now configure custom signals. For example, you can set up a signal that sends the "lot name" of a batch of images from a PLC to LandingEdge.

  <img alt="le_plc_DemoProgram_inputs_callout" />

  To allow you to include custom signals in Results Processing scripts in LandingEdge, we've added the `ReadInput` and `WriteOutput` methods. Use these methods to convert the signal values to variables that you can use in Python or C# scripts.

  For detailed information about setting up custom signals or using them in scripts, go to [PLC Workflow](./plc-workflow).
</Update>

<Update label="August 27, 2024">
  ## OCR with LandingEdge & Docker

  LandingAI now offers an optical character recognition (OCR) solution through LandingEdge and Docker. Use OCR to extract text from images to convert unstructured content into structured, actionable data. Our OCR solution supports English and Simplified Chinese character sets and can detect multiple languages in one image.

  This OCR solution is available as an add-on for users on the LandingLens Enterprise plan.

  When LandingEdge runs OCR on an image, the predicted text displays on the image and is included in the JSON response. For detailed information, go to [OCR](./ocr).

  <img alt="OCR_car" />

  <Info>The OCR solution through LandingEdge and Docker is not available for .</Info>
</Update>

<Update label="March 25, 2024 - v2.7.204">
  ## March 25, 2024 - v2.7.204

  We released a new version of LandingEdge today! The newest version includes these updates:

  * For Windows users only: When you install LandingEdge, LandingEdge will now check if your system has Microsoft Visual C++ Redistributable. If this package is not detected, LandingEdge will install it. For context, LandEdge requires the Microsoft C and C++ (MSVC) runtime libraries. The Microsoft Visual C++ Redistributable package installs these libraries.
  * We fixed an issue that caused OPC UA controller connections to PLCs to fail. For more information about using PLCs with LandingEdge, go to [PLC Workflow](./plc-workflow).
</Update>

<Update label="February 22, 2024 - v2.7.188">
  ## February 22, 2024 - v2.7.188

  You can use LandingEdge to upload images to a LandingLens project *without* running inference on those images. The images are uploaded to the Deploy page for the project in LandingLens. Images uploaded to the Deploy page can then be added to the project dataset.

  This method is particularly helpful if you want to upload images directly from a camera into LandingLens. For example, if you have an industrial camera on a manufacturing line, you can set up an Inspection Point in LandingEdge to capture images from that camera. That way, you don’t need to first download images from the camera and then upload them into LandingLens.

  To upload images using LandingEdge without running inference:

  1. Open **LandingEdge**.
  2. Open or create an Inspection Point.
  3. Set up the **Image Source**, **Inspection Start**, and **Cloud Connection** sections.
  4. Leave the **Model** section blank.
  5. In the **Image Saving** section, select the **Upload Results to LandingLens** checkbox.
     <img alt="Upload Results to LandingLens" />
  6. Click **Save Configuration**.
  7. When you're ready to upload images, click **Run Now** and upload the images using the method you selected in the **Image Source** section. For example, if you selected **Folder Watcher**, move the images you want to upload to the folder you selected.
  8. To see the images in LandingLens:1. Open the project in **LandingLens**.
  9. Click **Deploy**.
  10. In the **Self-Hosted Deployment** section, click the name of the Inspection Point that you created in **LandingEdge**.
  11. The images display.
      <img alt="LE_upload_no_model_2(2)" />
</Update>

<Update label="February 15, 2024 - v2.7.167">
  ## February 15, 2024 - v2.7.167

  In the newest version of LandingEdge, we’ve improved processing time and web API latency. We’ve also added a few improvements and bug fixes. Keep reading to learn more!

  ### Expanded Support for Industrial Cameras

  We’ve added an additional method, called "GigE Vision”, to run inference on images from industrial cameras. This is an alternate option to the “GenICam” option that is designed to be more efficient and robust. For more information on using industrial cameras, go to [GenICam and GigE Vision Cameras](./industrial-cameras).

  ### JSON Results Include Model ID and Latency

  When you run inference on an image via LandingEdge, the JSON results now include the Model ID (`model_id`) and Latency (`latency`) information.

  ### Send Images for Reference via URL

  If using web APIs to upload images for inference, you can now send a URL of the image. Previously, only an image file could be sent. Sending the image URL is supported by the `/images` endpoint. For more information about using web APIs, go to [Run Inference with Web APIs](./landingedge-apis).

  ### Bug Fixes

  * We fixed an issue that occurred in certain use cases with segmentation mask calculation.
  * We fixed issues related to the user interface.
  * We fixed issues related to running multiple GPUs.
</Update>

<Update label="September 26, 2023 - v2.6.87">
  ## September 26, 2023 - v2.6.87

  In the latest version of LandingEdge, you can now send images from different IP addresses (different devices) for inference using web APIs. You can enable this functionality by selecting the **Allow External Access** checkbox when setting up your Inspection Point. For more information, go to [Run Inference with Web APIs](./landingedge-apis).

  <img alt="le_webapi_1" />

  ### Bug Fixes

  * After running inference on an Anomaly Detection model, the results now display correctly in the user interface. (Anomaly Detection is deprecated and only available to legacy users.)
  * Role names are now easier to see in the User Menu.
</Update>

<Update label="August 24, 2023 - v2.6.45">
  ## August 24, 2023 - v2.6.45

  The newest version of LandingEdge offers these new features:

  * [Roles and Permissions](./landingedge-release-notes#roles-and-permissions)
  * [Assign GPUs to Inspection Points](./landingedge-release-notes#assign-gpus-to-inspection-points)
  * [Configurations](./landingedge-release-notes#configurations)

  ### Roles and Permissions

  Often, LandingEdge is deployed to a shared computer, such as a machine on a manufacturing floor. Several users might access both the machine and LandingEdge. To prevent users from accidentally changing Inspection Points or stopping the inspection process, LandingEdge now offers Roles to limit who can access different parts of the system:

  * **Admin**: Can access and edit all parts of LandingEdge.
  * **Engineer**: Can access and edit all parts of LandingEdge except for editing Role permissions.
  * **Operator**: Has read-only access.

  If LandingEdge has been idle for 15 minutes, the current user is logged out of the Role. You can then enter a password to log in as an Admin or Engineer. Or, you can log in as an Operator, who by default has read-only access.

  To manage Roles in LandingEdge, go to **Settings** > **Permissions**.

  <img alt="le_permissions_blank" />

  #### Do I need to do anything now that there are Roles?

  **If you would like to use Roles**, set up the passwords for the Admin and Engineer Roles. For detailed information, go to [Roles and Permissions](./roles-and-permissions).

  **If you don't plan on using Roles**—for example, if LandingEdge runs on a computer that only one person has access to—you don’t need to set up passwords or any of the Permissions settings. If you don’t set a password for any of the Roles, you won’t be logged out after the Idle Time.

  ### Assign GPUs to Inspection Points

  When setting up an Inspection Point, you can now assign one or more specific GPUs from your system to power the Inspection Point. This helps free up your CPU for other processes. For more information, go to [GPUs and LandingEdge](./gpus-and-landingedge).

  <img alt="le_pick_gpus_overview" />

  ### Configurations

  You can now set up multiple *configurations* for each Inspection Point. A **configuration** is the collection of settings for the Inspection Point. Set up multiple configurations if you want to switch between settings without changing the Inspection Point itself.

  If you're using a PLC, you can set it up to automatically switch between configurations. For more information about using a PLC with LandingEdge, go to [PLC Workflow](./plc-workflow).

  If you're not using a PLC, you can manually change the configuration in the LandingEdge interface.

  Configurations are managed in the **Configuration** field at the top of the Inspection Point settings.

  <img alt="le_config_intro" />

  #### If You Don't Need Multiple Configurations

  If you don't need multiple configurations for an Inspection Point, ignore the **Configuration** field.
</Update>

<Update label="July 11, 2023 - v2.5.10">
  ## July 11, 2023 - v2.5.10

  We've added more custom scripting capabilities to LandingEdge. You can now read out the raw scores from a Classification model. We've also introduced the `AllClasses` Dictionary, which provides access to all names and indices of all Classes in the model. For more information, go to [Custom Processing](./custom-processing).

  Here is a sample C# post-processing script for reading out the raw scores from a Classification model:

  ```csharp theme={null}
  public void Run()
  {
      if (Result.PrimaryResult is not ClassificationResult clf)
      {
          // not a classification result
          // this script is only applicable to classification, so exit the script
          return;
      }

      Log($"All classes in model: {string.Join(", ", AllClasses)}");
      Log($"Class scores for image: [{string.Join(", ", clf.Predictions.RawScores)}]");

      for (int i=0; i<AllClasses.Count; i++)
      {
          Log($"Class '{AllClasses[i].Name}' score = {clf.Predictions.RawScores[i]}");
      }    
  }
  ```
</Update>

<Update label="July 7, 2023">
  ## July 7, 2023

  The updated version of LandingEdge includes these updates:

  * You can now use LandingEdge to pull stills (individual frames) from videos and run inference on those images. For more information, go to [Image Source](./manage-inspection-points#image-source).
  * Support for the new API Key system. For more information, go to [API Keys](/api-key).
  * If you use LandingEdge with a PLC, you can now configure an Error Code output. For more information, go to [Outputs](./manage-inspection-points#outputs).
  * A few behind-the-scenes bug fixes.
</Update>

<Update label="June 14, 2023">
  ## June 14, 2023

  ### Download a Free Trial of LandingEdge

  You can now download a free trial of LandingEdge directly from LandingLens!

  To download the free trial, open a Project to the **Deploy** page and click **LandingEdge**. Then follow the on-screen prompts to complete the download. For detailed information, go to [LandingEdge Overview](./landingedge-overview).

  <img alt="LandingEdge" />
</Update>

<Update label="June 8, 2023">
  ## June 8, 2023

  ### What's New

  * The **Settings** icon is now permanently on the LandingEdge homepage, even if you haven’t created any Inspection Points yet. Previously, you could only access **Settings** after setting up an Inspection Point. This makes it easier to get your **License Key**, which you can access in **Settings** > **Update License**.

    <img alt="settings_no_ip" />

  * We've made it easier to see when your license will expire. If your license will expire within 120 days, a message on the Settings page notifies you how many days are left until the expiration date.
    <img alt="trial_license_4(1)" />

  Previously, if the license expired within 120 days, that notification would always be “Your license will expire in less than 120 days.”

  * If you try to upload an invalid license, you now get a pop-up letting you know that the license isn’t valid.
  * To make it easier to understand some of the features, we updated some of the user interface text throughout LandingEdge.

  ### Bug Fixes

  * We fixed a bug that caused issues when stopping inspections in some situations.
  * We fixed a few broken external references in our C# scripts.
</Update>

<Update label="May 12, 2023">
  ## May 12, 2023

  The latest release of LandingEdge makes it much easier to activate your Deployment License. Most notably, you can now get a 14-day free trial of LandingEdge! This is the perfect way to vet LandingEdge for your deployment needs.

  ### What’s New

  * You can now get a 14-day free trial of LandingEdge.
    <img alt="trial_license_1" />
  * LandingEdge now notifies you when your LandingEdge Deployment License will expire within 120 days, so that you can request a new license. LandingEdge also notifies you once your license has expired. Once you have your updated license, click the notification to add your license to LandingEdge.
    <img alt="LicenseExpiringSoon(1)" />
  * You can now update your LandingEdge license even if your current license is still valid. Previously, you could only add a LandingEdge license if your previous one was expired. With this new workflow, you can now avoid lapses to your LandingEdge functionality.
    <img alt="update_license_2" />
  * If you’ve enabled the [Upload Results to LandingLens](./manage-inspection-points#media-saving) setting, images uploaded to LandingLens via LandingEdge now have image metadata.
  * If you’ve enabled the [Upload Results to LandingLens](./manage-inspection-points#media-saving) setting, you can run a script to automatically skip saving certain images. For more information, go [here](./manage-inspection-points#sample-script-4-skip-saving-certain-images).

  ### Bug Fixes

  * Fixed a bug that caused changes to Inspection Point names to not save. LandingEdge now correctly saves changes to Inspection Point names.
  * Fixed a bug that caused the PLC information to not display in the Communication settings. The information displays correctly now.
</Update>

<Update label="April 12, 2023">
  ## April 12, 2023

  LandingEdge now supports Linux! You can run LandingEdge on Linux Ubuntu 20.04 and 22.04.

  When you download LandingEdge, select the Linux version. For detailed download instructions, go to [Download and Install LandingEdge](./download-and-install-landingedge#download-and-install-landingedge-on-linux).

  <img alt="Download_LE_Linux" />
</Update>

<Update label="April 5, 2023">
  ## April 5, 2023

  ### What's New

  * The **Settings** module now shows your LandingEdge version. For more information, go to [Version](./landingedge-settings#version).
    <img alt="LE_settings_version(1)" />

  * You have more ways to trigger image capture. For more information, go to [Inspection Start](./manage-inspection-points#inspection-start).- **Self**: Configure your camera or hardware device to trigger when the image will be taken. This is the only option for WebAPI and Folder Watcher.

  * **Manual**: In Manual mode, click the **Grab a Frame** button on the Monitor page to trigger the camera to capture the image.
    <img alt="manual_therm" />

  * You can now add image metadata by using the **Custom Scripting** feature. For more information, go to [Add Metadata to Images](./manage-inspection-points#sample-script-3-add-metadata-to-images).

    <img alt="script_metadata_before_2" />

    <img alt="script_metadata" />

  * When you attempt to close LandingEdge, you are now prompted to confirm the action, because closing the application stops all Inspection Points.
    <img alt="le_quit" />

  ### Bug Fixes

  * You can now download images that display in the image Preview. Previously, the download button was deactivated.
    <img alt="preview_download" />
  * Resolved issues with incorrect results for Object Detection Projects that occurred in some systems.
  * Resolved issues with high load conditions.
  * Fixed miscellaneous bugs.
</Update>

<Update label="March 23, 2023">
  ## March 23, 2023

  You can now customize and apply your own automation using C# or Python scripts to your Inspection Point in LandingEdge. This allows you to automate an action to occur before or after inference. For more information on custom processing, go to [Manage Inspection Points](./manage-inspection-points#custom-processing).

  To use this feature, download the latest version of LandingEdge. To learn more about how to download LandingEdge, go [here](./download-and-install-landingedge).
</Update>

<Update label="March 10, 2023">
  ## March 10, 2023

  LandingEdge v2 is now available! This newest version of LandingEdge includes some bug fixes and performance improvements. If you're using LandingEdge v1, we recommend upgrading to the newest version to get the latest developments.

  Please Note:

  * Any [Inspection Points](./manage-inspection-points) from LandingEdge v1 will not carry over to LandingEdge v2 and will need to be recreated as needed.
  * Webcams are not supported in LandingEdge v2.
  * The background application LandingEdge Inference Engine has been integrated into LandingEdge v2 and will no longer display as a separate application on your desktop.
</Update>


# LandingEdge Settings
Source: https://landinglens.docs.landing.ai/landingedge/landingedge-settings



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

<Info>If you don't see a feature described in this article, you might be on an outdated version of LandingEdge. Install the current version to get the latest features.</Info>

The LandingEdge **Settings** module has key information about your instance of LandingLens.

To open **Settings**:

1. Click the **Settings** (gear) icon in the top right corner of the LandingEdge homepage.
   <img alt="LE_settings_home" />
2. The general settings display. Here, you can view your LandingEdge version, download a diagnostics file, and configure the Auto Start setting.
   <img alt="LE_settings_primary_2024" />

## Version

To view your version of LandingEdge:

1. Click the **Settings** (gear) icon in the top right corner of the LandingEdge homepage.
2. View your LandingEdge version in the **Version** section.
   <img alt="LE_settings_version_2024" />

## Download Diagnostics

<iframe title="YouTube video player" />

In some cases, a  representative might ask you to share a Diagnostics file from LandingEdge. This file contains logs and other data from LandingEdge that can help resolve issues.

To download the LandingEdge diagnostics file:

1. Click the **Settings** (gear) icon in the top right corner of the LandingEdge homepage.
2. Click **Download Diagnostics**.
   <img alt="LE_settings_diagnostics_2024" />
3. A ZIP file is download to your computer. Email the file to the  representative.

<Warning>Do not share your Diagnostics file on any public forum, because this file might contain sensitive information.</Warning>

## Auto Start

<Info>The Auto Start setting is only supported on Windows computers.</Info>
You can configure LandingEdge to start automatically when your Windows computer starts. To do this:

1. Click the **Settings** (gear) icon in the top right corner of the LandingEdge homepage.
2. Select the **Start LandingEdge with Windows** checkbox.
   <img alt="LE_settings_autostart_2024" />


# Use LandingEdge with LandingLens on Snowflake
Source: https://landinglens.docs.landing.ai/landingedge/landingedge-snowflake



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✖</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

Users of both LandingLens and  can use LandingEdge to run inference.

Most of the LandingEdge processes are the same for both LandingLens and —you choose an image source, an action that triggers inference, and the LandingLens model that runs inference.

**The only difference occurs if you want to run LandingEdge "online"**. This means that LandingEdge uses an Internet connection to load the model from . Running LandingEdge online also allows you to upload inference results back to , so that you can save images to your project in a process called Continuous Learning.

If you want to run LandingEdge online with , follow the instructions in this article. Otherwise, if you want to run LandingEdge "offline", follow the general instructions in [Manage Inspection Points](./manage-inspection-points).

<Info>LandingEdge v2.8.45.0 and later supports .</Info>

## Considerations for Running LandingEdge Online with&#x20;

If you enable running LandingEdge online with , you will *only* be able to use LandingEdge to run models online with . You won't be able to run models offline or run models from the LandingAI-hosted version of LandingLens until you disable the connection with .

## Set Up an Online Connection with LandingLens on Snowflake

If you want to run LandingEdge online with , set up a connection between the two applications using the following instructions:

1. Open LandingEdge.
2. Click the **Settings** (gear) icon in the top right corner of the LandingEdge homepage.
   <img alt="LE_settings_home" />
3. Click **Snowflake**.
4. Select the **Use Snowflake** checkbox.
5. Fill out the fields:
   * **Snowflake App URL**: Enter the fully qualified domain of your instance of . For example, the URL could be `https://example.snowflakecomputing.app/`.
   * **Snowflake Account**: Enter your Snowflake account [locator](https://docs.snowflake.com/en/user-guide/admin-account-identifier#format-2-account-locator-in-a-region). One way to find your account locator is to open a worksheet in Snowsight and run `SELECT CURRENT_ACCOUNT();`. For more information, go to the [Snowflake documentation](https://docs.snowflake.com/en/sql-reference/functions/current_account).
   * **Snowflake Username**: Enter your Snowflake username as it appears in your Snowsight profile. (This is the `NAME` property in Snowflake.)
6. Click **Generate New Private Key**. LandingEdge creates a private key and saves it to your hard drive.
7. Click **Copy Public Key**. (You will later assign the public key to yourself in Snowflake.)
8. If you're using AWS PrivateLink or your Snowflake account locator has underscores, select the **Use AWS PrivateLink** checkbox.
9. Click **Save**.
   <img alt="setup_LE_SF" />
10. Assign the public key to yourself in Snowflake. To learn how to do this, go to the [Snowflake documentation](https://docs.snowflake.com/en/user-guide/key-pair-auth#assign-the-public-key-to-a-snowflake-user).
11. To verify that LandingEdge successfully connected to , set up an inspection point. If your projects display in the **Project Connected to** drop-down menu, the connection works. If you don't see any projects, check if all Snowflake account information was entered correctly.
    <img alt="verify_LE_SF_connection(2)" />

## Set Up an "Online" Inspection Point

After you've set up the [Snowflake settings](./landingedge-snowflake#set-up-an-online-connection-with-landinglens-on-snowflake) in LandingEdge, you can set up Inspection Points, which are the sets of information needed to deploy models in LandingEdge. For the most part, you can follow the instructions in [Manage Inspection Points](./manage-inspection-points) to set up an Inspection Point. The only difference is how you fill out the **Cloud Connection** and **Model** settings:

1. Select your project from the **Project Connected to** drop-down menu.
   <img alt="verify_LE_SF_connection(2)" />
2. Select **Download from LandingLens**.
3. Click **Select**.
   <img alt="model_online_new_3" />
4. Select the model you want to use and click **Download Model**.
   <img alt="LE_SF_downloadModel" />
5. LandingEdge loads the model. When this is complete, the **Model successfully loaded message** displays and the **Run Now** button becomes active.
   <img alt="LE_SF_modelLoaded" />
6. Continue setting up the Inspection Point.

## Disable the Online Connection with&#x20;

If you no longer want LandingEdge to be connected to , deselect the **Use Snowflake** checkbox on LandingEdge's Snowflake settings page. This disconnects all Inspection Points that were connected to .

<img alt="disable_LE_SF" />


# LandingEdge Requirements
Source: https://landinglens.docs.landing.ai/landingedge/landingedge-specifications-sheet



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

## System Requirements

| Item                        | Requirement                                                                                                                                                                                                                                                                                          |
| --------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Supported Operating Systems | <ul><li>Windows 10 Pro</li><li>Windows 10 Enterprise</li><li>Windows 10 IoT Enterprise</li><li>Windows 11 Pro</li><li>Windows Server 2016</li><li>Windows Server 2019</li><li>Windows Server 2022</li><li>Linux Ubuntu 20.04 and 22.04 on x64 processors (does not support ARM processors)</li></ul> |
| Memory                      | Minimum of 16 GB of RAM (recommended)                                                                                                                                                                                                                                                                |
| Processor                   | Must support Intel AVX2<br /><br />Minimum: Intel Core i3 or AMD Ryzen 1000<br />Recommended: Intel Core i5 or AMD Ryzen 3000 (or better/similar)                                                                                                                                                    |

*1. For Intel processors, this generally includes CPUs that have Haswell microarchitecture or later (released after 2013). For AMD processors, this generally includes CPUs that have Excavator microarchitecture or later (released after 2015).*

<Info>LandingEdge is not compatible with macOS.</Info>
<Info>LandingEdge doesn't deploy  models. The only deployment option for  is [Cloud Deployment](/cloud-deployment).</Info>

## GPU Support

Using a GPU is optional. If you plan on using a GPU, we recommend using an NVIDIA GPU with at least 8 GB of RAM. LandingEdge supports CUDA compute capability 5.2 to 12.1 (Maxwell to Blackwell architectures). For example:

* GeForce GTX 1070 through GeForce RTX 5090
* Quadro P4000 through RTX PRO 6000 Blackwell
* Tesla P4 through RTX PRO 6000 Blackwell Server

For best performance, we recommend using the Ampere architecture or later. For example:

* GeForce RTX 3050 through GeForce RTX 50xx
* Quadro RTX A2000 through RTX PRO Blackwell
* A10 through RTX PRO Blackwell

The following table lists the minimum required driver version for NVIDIA GPUs.

| Operating System | Minimum Driver Version |
| ---------------- | ---------------------- |
| Windows          | 528.33 or later        |
| Linux            | 525.60.13 or later     |

## GenICam Support

You can use GenICam-compliant industrial cameras with LandingEdge.

You must install a GenTL Producer in order for LandingEdge to communicate with the camera. A GenTL Producer is the transport layer interface that enables the camera and LandingEdge to communicate with each other.

The GenTL Producer is often included as part of your camera manufacturer's SDK, like the Basler Pylon SDK or Allied Vision Vimba SDK. If you're having trouble finding the GenTL Producer for your camera, try the SDK for your manufacturer.

## Supported Image File Types

LandingEdge can run inference on the following image file types:

* **PNG**
* **BMP**
* **JPG**
* **JPEG**
* **TIFF**
* **MPO**: An MPO file is a Multi-Picture Object file. It contains two JPG files that create a stereoscopic image when overlaid. When you upload an MPO file to LandingEdge, LandingEdge selects one of the two JPG files. Sometimes, a JPG from a smart phone might be interpreted as an MPO because it contains the main image and an embedded thumbnail. In this case, LandingEdge selects the main image.


# Landingedge Troubleshooting
Source: https://landinglens.docs.landing.ai/landingedge/landingedge-troubleshooting



## LandingEdge isn't detecting my camera.

If you have multiple GenTL producers installed, LandingEdge will not be able to detect your camera. Please make sure that only one GenTL producer is installed and try again.


# LandingEdge Workflow
Source: https://landinglens.docs.landing.ai/landingedge/landingedge-workflow



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

This is a high-level workflow of LandingEdge:

1. Make sure your computer meets the [system requirements](./landingedge-specifications-sheet).
2. Download and install [LandingEdge](./download-and-install-landingedge).
3. [Activate the project](/activate-projects) that has the model you want to run inference with. You must activate a project in LandingLens first, regardless if you will run the model online or offline.
4. If you plan to run inference offline, [download the model](/download-models) you want to run inference with.
5. If you're using  and plan to run inference online, [set up a connection](./landingedge-snowflake) between LandingEdge and .
6. Create and configure an [Inspection Point](./manage-inspection-points).
7. If you want to upload the images that you run inference on back to LandingLens, enable the **Upload Results to LandingLens** setting when setting up the Inspection Point.


# Manage Inspection Points
Source: https://landinglens.docs.landing.ai/landingedge/manage-inspection-points



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span> (see exceptions below)</td>
    </tr>
  </tbody>
</table>

## Inspection Point Overview

An **Inspection Point** is the set of information needed to deploy your model in LandingEdge. When you set up an Inspection Point, you identify the source of the images that you'll run inference on, the model that will run inference, and a few other settings.

This article guides you through the basic steps for creating an Inspection Point. Some use cases—like using PLCs—require additional or specific steps. Please read any of these articles that are relevant to your use case before setting up an Inspection Point:

* [Use LandingEdge with LandingLens on Snowflake](./landingedge-snowflake)
* [PLC Workflow](./plc-workflow)
* [GenICam and GigE Vision Cameras](./industrial-cameras)
* [GPUs and LandingEdge](./gpus-and-landingedge)
* [Custom Processing](./custom-processing)

<Info>LandingEdge doesn't deploy  models. The only deployment option for  is [Cloud Deployment](/cloud-deployment).</Info>

<Info>If you don't see a feature described in this article, you might be on an outdated version of LandingEdge. Install the current version to get the latest features.</Info>

## Create Inspection Points

1. Click **Add Inspection Point**.
   <img alt="addInspectionPoint_1" />
2. Enter a short, descriptive name for the Inspection Point in the **Inspection Point Name** field.
3. Click **Add Inspection Point**.
   <img alt="addInspectionPoint_2" />
4. Select an [Image Source](./manage-inspection-points#image-source), which is where LandingEdge will get images from.
5. Select an [Inspection Start](./manage-inspection-points#inspection-start), which determines when and how often LandingEdge gets images.
6. Use the [Cloud Connection and Model](./manage-inspection-points#cloud-connection-and-model-connect-to-a-landinglens-model) settings to select a LandingLens model.
7. Depending on your use case, you might need to set up these settings: [Communication](./manage-inspection-points#communication), [Image Saving](./manage-inspection-points#image-saving), [Other Settings](./manage-inspection-points#other-settings), and [Custom Processing](./custom-processing).
8. Click **Save Configuration**.
   <img alt="addInspectionPoint_3" />

## Inspection Point Settings

This section describes the Inspection Point settings:

* [Image Source](./manage-inspection-points#image-source)
* [Preview Settings](./manage-inspection-points#preview-settings)
* [Inspection Start](./manage-inspection-points#inspection-start)
* [Cloud Connection and Model](./manage-inspection-points#cloud-connection-and-model-connect-to-a-landinglens-model)
* [Communication](./manage-inspection-points#communication) (only applicable if using a PLC)
* [Image Saving](./manage-inspection-points#image-saving) (optional)
* [Other Settings](./manage-inspection-points#other-settings) (optional)
* [Custom Processing](./custom-processing) (optional)

### Image Source

<Info>LandingEdge does not support smart cameras.</Info>
Use the **Image Source** drop-down menu to select where you want LandingEdge to capture images from.

#### Web API

Select **Web API** from the **Image Source** drop-down menu to send images for inference via API. Enter any number from 7,000 to 8,000. This will be your port number for your API. LandingEdge will monitor this port number to receive images from your API call.

For detailed information about sending images for inference via API, go to [Run Inference with Web APIs](./landingedge-apis).

<img alt="web_api" />

#### GigE Vision Camera

Select **GigE Vision Camera** from the **Image Source** drop-down menu to capture images from an industrial camera using the [GigE Vision Camera](https://www.automate.org/vision/vision-standards/vision-standards-gige-vision) interface standard.

For detailed information about capturing images from industrial cameras, go to [GenICam and GigE Vision Cameras](./industrial-cameras).

<img alt="image_source_gige" />

#### Video

Select **Video** from the **Image Source** drop-down menu to tell LandingEdge to pull stills (individual frames) from a video and run inference on those images.

Configure these settings:

* **Source**: Enter the URL or RTSP address for the video you want to pull stills from.
* **Frame Acquisition Mode**: Select if you want **Frames per Second** (pulls the specified number of frames per second) or **Frame Interval** (pulls one frame out of the specified number of frames).
* **Frames / Sample Every #**: Select the number of frames for the selected **Frame Acquisition Mode**.

<img alt="image_source_video" />

#### GenICam

Select **GenICam** from the **Image Source** drop-down menu to capture images from an industrial camera using the [GenICam](https://www.emva.org/standards-technology/genicam/) interface standard.

For detailed information about capturing images from industrial cameras, go to [GenICam and GigE Vision Cameras](./industrial-cameras).

<img alt="image_source_GenICam" />

#### Folder Watcher

Select **Folder Watcher** from the **Image Source** drop-down menu to run inference on images added to a folder. Then, select the folder you want to pull images from.

LandingEdge only runs inference on images added to the folder after you click **Run Now**. It won't run inference on images already in the folder, or on images added when the Inspection Point isn't running.

<img alt="folder_watcher" />

### Preview Settings

The **Preview** settings display after you have configured your [Image Source](./manage-inspection-points#image-source). They are only applicable to GenICam cameras. These are the settings:

* **View Live**: See a live feed of your camera's view. This is useful to check if the camera is in focus or facing the right direction, for example.
* **Grab a Frame**: Take a picture using the connected camera. This option does not work in View Live. This will run inference if you have a model loaded.
* **Save to Disk Automatically**: Automatically save images captured by the **Grab a Frame** setting. (This setting will not save images from View Live.)
  <img alt="Preview Settings" />

### Inspection Start

Select how often you want the camera to capture images from the **Inspection Start** drop-down menu:

* **Timer**: Set the timed interval (in seconds) in which the camera will take a picture.
  <img alt="Inspection Start" />
* **PLC**: Configure your Programmable Logic Controller ([PLC](https://en.wikipedia.org/wiki/Programmable_logic_controller)) to determine how often you want the camera to take a picture. For information about using a PLC with LandingEdge, go to [PLC Workflow](./plc-workflow).
* **Self**: Configure your camera or hardware device to trigger when the image will be taken. This is the only option for Web API, Video, and Folder Watcher.
* **Manual**: In Manual mode, click the **Grab a Frame** button on the Monitor page to trigger the camera to capture the image.
  <img alt="manual_therm" />

### Cloud Connection and Model: Connect to a LandingLens Model

Use the **Cloud Connection** and **Model** settings to connect the Inspection Point to a model in LandingLens. You must [activate the project](/activate-projects) that has the model you want to run inference with *before* you can use it in LandingEdge, regardless if you will run the model online or offline.

The method you use for selecting a model depends on how you want to set up LandingEdge:

* **Online Use**: If you want to connect LandingEdge directly to LandingLens (via API credentials) and select the model directly in LandingEdge, go to [Select a LandingLens Model for Online Use](#select-a-landinglens-model-for-online-use). (If you're using , go [here](./landingedge-snowflake) instead.)
* **Offline Use**: If you want to download your model from LandingLens and then load it to LandingEdge, go to [Select a LandingLens Model for Offline Use](#select-a-landinglens-model-for-offline-use). Offline use is helpful if your system doesn't have internet access or has limited bandwidth (which could make it difficult for LandingEdge to get the model directly from LandingLens).

#### Select a LandingLens Model for Online Use

If you're using , go [here](./landingedge-snowflake) instead.

1. [Activate the project](/activate-projects) that you has the model you want to run inference with, if you haven't already.
2. Open your Inspection Point in LandingEdge.
3. Go to the **Cloud Connection** section.
4. Enter your **API Key**. To generate this credential, go to [API Keys](/api-key).
5. If using LandingEdge v2.5.5 or later, leave the **API Secret** field blank. If using an earlier version, enter a minimum of one alphanumeric character in the **API Secret** field. For more information, go to [API Keys](/api-key).
6. Click **Connect**.
   <img alt="model_online_new" />
7. The **Cloud Connection** is marked as **On**.
8. Select your **Project** from the drop-down menu.
   <img alt="model_online_new_2" />
9. Go the **Model** section.
10. Select **Download from LandingLens**.
11. Click **Select**.
    <img alt="model_online_new_3" />
12. Select the **Model** you want to use and click **Download Model**.
    <img alt="model_online_new_4" />
    LandingEdge loads the model. When this is complete, the **Model successfully loaded** message displays and the **Run Now** button becomes active.
    <img alt="model_online_new_5" />

#### Select a LandingLens Model for Offline Use

1. [Activate the project](/activate-projects) that you has the model you want to run inference with, if you haven't already.
2. [Download your model](/download-models) from LandingLens, if you haven't already.
3. Open your Inspection Point in LandingEdge.
4. Leave the fields in the **Cloud Connection** section blank.
   <img alt="model_offline_1" />
5. Go to the **Model** section.
6. Select **Load Offline**.
7. Click **Select**.
   <img alt="model_offline_2" />
8. Navigate to the zipped model on your device and select it.LandingEdge loads the model. When this is complete, the **Model successfully loaded** message displays and the **Run Now** button becomes active.
   <img alt="model_offline_3" />

### Communication

Fill out the Communication section only if you're using a PLC with LandingEdge. For detailed information, go to [PLC Workflow](./plc-workflow).

### Image Saving

Use the **Image Saving** section to save images to your hard drive (Save Locally) and LandingLens.

#### Save Locally

You can save all images captures from LandingEdge to your hard drive using **Save Locally**. When this feature is enabled, all images from LandingEdge are saved to your hard drive until there is 5% storage space left.

To save images to your hard drive:

1. Select a file type (JPG or PNG).
2. Select the **Save Locally at** checkbox.
3. If you want to change the location where images are saved, click **Change** and select a new folder.
   <img alt="saveLocally" />

#### Upload Results to LandingLens

If you're running LandingEdge [online](./manage-inspection-points#select-a-landinglens-model-for-online-use) and have enabled [Save Locally](./manage-inspection-points#save-locally), you can save images back to LandingLens. You can then load the images into your dataset, label them, and retrain your model. This process is called Continuous Learning.

To enable save images back to LandingLens, select the **Upload results to LandingLens** checkbox.

<img alt="uploadResultsLL" />

### Other Settings

If you want to run the Inspection Point each time your Windows computer starts, select the **Start running automatically when LandingEdge starts** checkbox.

<img alt="Other Settings" />

<Info>The Auto-Start setting is only supported on Windows computers.</Info>

### Custom Processing

For information about how to create and run custom scripts in LandingEdge, go to [Custom Processing](./custom-processing).

## Save Configuration / Run Now

After you have configured your Inspection Point, click **Save Configuration** to save your changes.

You can click **Run Now** to start automatically running inference. (You must save your Inspection Point before you can run inference.)

Indicates how certain the AI is that its Prediction is correct. For example, in the screenshot below, the AI is 0.94 (or 94%) confident that their Prediction is a screw.


# OCR
Source: https://landinglens.docs.landing.ai/landingedge/ocr



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✖</span></td>
    </tr>
  </tbody>
</table>

LandingAI offers an optical character recognition (OCR) solution through LandingEdge and Docker. Use OCR to extract text from images to convert unstructured content into structured, actionable data. Our OCR solution supports English and Simplified Chinese character sets and can detect multiple languages in one image.

This OCR solution is available as an add-on for users on the LandingLens Enterprise plan.

When LandingEdge runs OCR on an image, the predicted text displays on the image and is included in the [JSON response](./ocr#ocr-json-response).

<img alt="OCR_car" />

## Activation Keys

Using OCR in LandingEdge or Docker requires an activation key. The same activation key can be used for both LandingEdge and Docker.

If you've purchased the OCR add-on and need your activation key, contact [support@landing.ai](mailto:support@landing.ai).

## OCR in LandingEdge

OCR is available in LandingEdge v2.9.1 and later. To use OCR in LandingEdge, first [enter your activation key](./ocr#enter-the-activation-key-in-landingedge) in the LandingEdge settings. Then, you can [create an Inspection Point](./ocr#run-ocr-in-landingedge) for OCR.

### Enter the Activation Key in LandingEdge

Once you have an OCR activation key, follow the instructions below to add it to LandingEdge:

1. Open LandingEdge.
2. Click the **Settings** (gear) icon in the top right corner of the LandingEdge homepage.
   <img alt="LE_settings_home" />
3. Click **OCR**.
4. Enter the activation key in the **OCR Activation Key** field.
5. Click **Save**.
   <img alt="OCR_activationKey" />

### Run OCR in LandingEdge

After you've entered the activation key in LandingEdge, you can set up an Inspection Point to run OCR. To do this, follow the instructions below:

1. Create an Inspection Point in LandingEdge.
2. Set up the **Image Source** and **Inspection Start** settings.
3. Skip the **Cloud Connection** section.
4. Select **OCR** from the **Model** drop-down menu.
   <img alt="OCR_selectOCR" />
5. Set up the other settings if needed.
6. Click **Save Configuration**.
7. Click **Run**.
8. When you run OCR in LandingEdge, the results display in the user interface. There is a box around each detected string of text and the predicted text displays above that box. The results are also included in the [JSON response](./ocr#ocr-json-response).
   <img alt="OCR_shippingLabel" />

## OCR with Docker

You can run the LandingAI OCR tool with the [LandingAI Deploy Docker](./docker-deploy) solution. OCR is available in LandingAI Docker v2.9.1 and later.

First, launch a Docker container with the LandingAI OCR model. To do this, include your LandingAI OCR activation key and the  `run-ocr` command when launching a container. For example:

```shell theme={null}
docker run -e LANDING_LICENSE_KEY="your_activation_key" -p 8000:8000 public.ecr.aws/landing-ai/deploy:latest run-ocr
```

After launching the Docker container with the OCR tool, you can run OCR on images the same way you would send images for inference. For detailed information, go to [LandingAI Docker](./docker-deploy).

## OCR JSON Response

The following table describes the objects in the JSON response for OCR models. An example response is here.

| Element                 | Description                                                                                                                                                                                                                                                                                                |
| ----------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `type`                  | The name of the prediction type. This will always be `OCR`.                                                                                                                                                                                                                                                |
| `predictions`           | This object contains the information for each string of text the model detected. Each prediction is a separate object nested in the `predictions` object.<br /><br />Predictions are listed in alphanumeric order.                                                                                         |
| `text`                  | The predicted text of the string.                                                                                                                                                                                                                                                                          |
| `score`                 | The confidence score for the prediction.                                                                                                                                                                                                                                                                   |
| `location`              | This object contains the pair of x and y coordinates (in pixels) of each corner of the bounding box of the predicted string. Each coordinate is a separate object nested in the location object.<br /><br />The coordinates start with the bottom left corner of the bounding box and go counterclockwise. |
| `metadata`              | This element contains nested metadata from the image. If the [Image Source](./manage-inspection-points#image-source) is **Folder Watcher**, some data is populated by default. You can use [scripts](./custom-processing#add-metadata-to-images) and web APIs to set or override the values.               |
| `image_id`              | If the [Image Source](./manage-inspection-points#image-source) is **Folder Watcher**, this is the file name of the image. Otherwise, this object is blank. You can use [scripts](./custom-processing#add-metadata-to-images) and web APIs to set or override the values.                                   |
| `inspection_station_id` | This element is blank by default. You can use [scripts](./custom-processing#add-metadata-to-images) and web APIs to set or override the values.                                                                                                                                                            |
| `location_id`           | If the [Image Source](./manage-inspection-points#image-source) is **Folder Watcher**, this is the directory that the image is in. Otherwise, this object is blank. You can use [scripts](./custom-processing#add-metadata-to-images) and web APIs to set or override the values.                           |
| `capture_timestamp`     | The time and date that OCR was run on the image. You can use [scripts](./custom-processing#add-metadata-to-images) and web APIs to set or override the values.                                                                                                                                             |
| `model_id`              | This will always be `OCR`.                                                                                                                                                                                                                                                                                 |
| `latency`               | The `latency` object includes the detailed timing statistics of the inference call.<br /><br />Each key-value pair in the `latency` object represents a step in the inference process, and the duration of that step. All values are measured in seconds.                                                  |

### Example: OCR JSON Response

The following image and code snippet show the OCR model's predictions. The model correctly predicted two strings of text: "ROAD" and "CLOSED".

<img alt="OCR_RoadClosed" />

```json theme={null}
{
    "type": "OCR",
    "predictions": [
        {
            "text": "CLOSED",
            "score": 0.98919207,
            "location": [
                {
                    "x": 1639,
                    "y": 1712
                },
                {
                    "x": 1650,
                    "y": 1454
                },
                {
                    "x": 2687,
                    "y": 1496
                },
                {
                    "x": 2676,
                    "y": 1755
                }
            ]
        },
        {
            "text": "ROAD",
            "score": 0.9103826,
            "location": [
                {
                    "x": 1778,
                    "y": 1368
                },
                {
                    "x": 1787,
                    "y": 1100
                },
                {
                    "x": 2542,
                    "y": 1126
                },
                {
                    "x": 2533,
                    "y": 1394
                }
            ]
        }
    ],
    "metadata": {
        "image_id": "malachi-brooks-SmgvToT3nbA-unsplash.jpg",
        "inspection_station_id": "",
        "location_id": "/Users/user/Desktop/folder",
        "capture_timestamp": "2024-08-14T18:27:28.286829-07:00"
    },
    "model_id": "OCR",
    "latency": {
        "decoding_s": 0.1738631,
        "preprocess_s": 0.0030414,
        "waiting_s": 0.0,
        "infer_s": 0.0826073,
        "postprocess_s": 0.0133133
    }
}
```


# PLC Workflow
Source: https://landinglens.docs.landing.ai/landingedge/plc-workflow



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

You can use Programmable Logic Controllers (PLCs) to communicate with LandingEdge. For example, you can configure the system so that the PLC tells LandingEdge when to take a photo, and then LandingEdge tells the PLC what the results were.

<img alt="LE_Workflow_PLC_2024" />

<Info>If using an industrial camera, you can configure a PLC to trigger image capture. To learn how to set up industrial cameras in LandingEdge, go to [GenICam and GigE Vision Cameras](./industrial-cameras).</Info>

## Supported Controllers

LandingEdge is compatible with the following PLCs:

* Rockwell CompactLogix controllers
* Rockwell ControlLogix controllers
* Controllers that use the Open Platform Communications Unified Architecture (OPC UA) protocol

## Set Up Inspection Points for PLCs

<Info>You can set up multiple *configurations* for each Inspection Point.</Info>

To set up Inspection Points when using a PLC with LandingEdge, follow the instructions below:

1. Create an Inspection Point.
2. Select your [Image Source](./manage-inspection-points#image-source).If you want the PLC to trigger the inspection start and you are capturing images with a connected industrial camera, select **GigE Vision Camera** or **GenICam** and then select your camera.
   <img alt="plc_image_source" />
3. Select your [Inspection Start](./manage-inspection-points#inspection-start) method.If using an industrial camera, select **PLC**. Make sure you configure your PLC to start inspections. This will vary based on your PLC device.
   <img alt="plc_inspection_start" />
4. Set up the [Cloud Connection and Model](./manage-inspection-points#cloud-connection-and-model-connect-to-a-landinglens-model)settings.
   <img alt="plc_model" />
5. Complete the following steps in the **Communication** section.
6. Select your **PLC Type**.
   <img alt="plc_plc_type" />
7. Enter the IP address of the controller in the **Address** field.
   * For Rockwell controllers, use this format: \[*IP Address*]/\[*Slot Number*].Example: **192.168.1.5/0**. (If there's no slot number, omit it.)
   * For OPC UA controllers, use this format: opc.tcp\://\[*IP Address*]:4840.Example: **opc.tcp\://192.168.1.10:4840**.
     <img alt="plc_address" />
8. Click **Set** to set up the [Inputs](./plc-workflow#inputs) and [Outputs](./plc-workflow#outputs), which are the data points that LandingEdge and the PLC can share with each other.
   <img alt="le_plc_set" />
9. Click **Add New Signal**.
   <img alt="le_plc_add_newSignal" />
10. Select an option from the **Signal** drop-down menu. For detailed information about the options, go to [Inputs](./plc-workflow#inputs) and [Outputs](./plc-workflow#outputs).
11. If you selected **Custom**, enter the **Name** and **Data Type**.If you selected an existing signal type, these fields auto-populate and can't be changed.
12. Enter the PLC Tag or Tag Address in the **Tag/Address** field for that data point. This field isn't case-sensitive. For information about how to program your PLC, refer to the device manufacturer's documentation.For example, the images below show the signals in the PLC application and the matching signals in LandingEdge:
    <img alt="le_plc_DemoProgram_tags" />
    <img alt="le_plc_DemoProgram_inputs_outputs" />
13. After you've set up all the signals, click **Set Inputs & Outputs**.
14. Confirm that the **Communication** panel shows the number of signals you've set up.
    <img alt="plc_io" />
15. (Optional) Set up [Image Saving](./manage-inspection-points#image-saving) settings.
16. (Optional) Set up [Other Settings](./manage-inspection-points#other-settings) settings.
17. (Optional) Set up [Custom Processing](./custom-processing).

## Inputs

Use the **Inputs** settings to configure the signals that the PLC sends to LandingEdge.

The following table describes the configurable inputs.

| Input                           | Description                                                                                                                                                                                                                                                                                                                     | Paired Output                   | Data Type                                                 |
| ------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------- | --------------------------------------------------------- |
| Trigger                         | Takes images immediately when the Trigger goes from Low to High (False to True).                                                                                                                                                                                                                                                | Trigger Ready                   | Bool                                                      |
| Results Ack                     | Configure the PLC to set this setting to High (True) to indicate results and errors from LandingEdge have been received. When LandingEdge receives this signal, it resets the result signals and is ready to start the cycle again.                                                                                             | Results Ready, Error            | Bool                                                      |
| Request Sub-Configuration Index | The PLC can tell LandingEdge to change to a different Inspection Point [configuration](./configurations). Use the configuration Index, and not the configuration name.<br /><br />If you're not using multiple configurations for an Inspection Point, leave this blank.<br /><br />Available in LandingEdge v2.6.45 and later. | Current Sub-Configuration Index | Dint                                                      |
| Custom                          | Set up a custom signal that the PLC sends to LandingEdge. For example, this can be the "lot name" for a batch of images.<br /><br />Available in LandingEdge v2.10.x and later.                                                                                                                                                 | N/A                             | Must match the data type set in the PLC application<br /> |

<Info>
  Refer here to understand the signals emitted by LandingEdge and the PLC:<br />
  • <strong>True/High</strong>: Indicates that the value is on.<br />
  • <strong>False/Low</strong>: Indicates that the value is off.
</Info>

## Outputs

Use the **Outputs** settings to configure the signals that LandingEdge sends to the PLC.

The following table describes the configurable outputs.

| Output                          | Description                                                                                                                                                                                                                                                                       | Paired Input                    | Data Type                                           |
| ------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------- | --------------------------------------------------- |
| Trigger Ready                   | Indicates LandingEdge is ready to receive the trigger to capture and process an image.                                                                                                                                                                                            | Trigger                         | Bool                                                |
| Results Ready                   | Indicates inference is complete and results are ready on the output signals to be read by the PLC.                                                                                                                                                                                | Results Ack                     | Bool                                                |
| Results OK                      | Indicates the image is good. This is the default result if you are running a Classification Model.                                                                                                                                                                                | N/A                             | Bool                                                |
| Results NG                      | Indicates that the image is not good. An **Error** output will also be present.                                                                                                                                                                                                   | N/A                             | Bool                                                |
| Classification                  | This option is only for Classification Models. Indicates the predicted Class ID.<br /><br />If there is no image, the value is **-1**.                                                                                                                                            | N/A                             | Dint                                                |
| Error                           | Indicates an error occurred during acquisition or processing. Check the **Error Code** for more details. A **Results NG** output will also be present.<br /><br />To clear the error, assert the **Results Ack** input.                                                           | Results Ack                     | Bool                                                |
| Error Code                      | Indicates what kind of error occurred in the DINT data type. <ul><li>**All 0 bits**: No error</li><li>**A 1 in bit 0**: Non-specific error</li><li>**A 1 in bit 1**: Timeout during acquisition</li><li>**Bits 2-31**: Reserved for future use</li></ul>                          | N/A                             | Dint                                                |
| Online/Ready                    | Indicates LandingEdge is running.                                                                                                                                                                                                                                                 | N/A                             | Bool                                                |
| Heartbeat                       | LandingEdge toggles the value from True to False every 1 second. This allows the PLC to check if LandingEdge is still functioning and that the connection between the PLC and LandingEdge still exists.                                                                           | N/A                             | Bool                                                |
| Busy                            | Indicates LandingEdge is processing.                                                                                                                                                                                                                                              | N/A                             | Bool                                                |
| Current Sub-Configuration Index | LandingEdge tells the PLC the Index of the Inspection Point [configuration](./configurations) that is currently running.<br /><br />If you're not using multiple configurations for an Inspection Point, leave this blank.<br /><br />Available in LandingEdge v2.6.45 and later. | Request Sub-Configuration Index | Dint                                                |
| Custom                          | Set up a custom signal that LandingEdge sends to the PLC. For example, this can be the x and y coordinates of a bounding box.<br /><br />Available in LandingEdge v2.10.x and later.                                                                                              | N/A                             | Must match the data type set in the PLC application |

<Info>
  Refer here to understand the signals emitted by LandingEdge and the PLC:<br />
  • <strong>True/High</strong>: Indicates that the value is on.<br />
  • <strong>False/Low</strong>: Indicates that the value is off.
</Info>

## Test Inputs and Outputs

To test if a signal can be sent between LandingEdge and the PLC, click **Test**. If the signal works, **Success** displays. If not, **Fail** displays.

If the test fails, check if the Name, Data Type, and Tag/Address in LandingEdge match the information in the PLC application.

For example, the Custom "lot" signal in the image below failed because its address was incomplete.

<img alt="le_plc_inputs_failed" />

## Example Setup of LandingEdge and a PLC

The following [example workflow](./plc-workflow#example-workflow) shows how setting up the Inputs and Outputs enable LandingEdge and the PLC to work together.

The example assumes that these Inputs and Outputs are set up:

| Input                           | Set Up                                         |   |        |        |
| ------------------------------- | ---------------------------------------------- | - | ------ | ------ |
| Trigger                         | ✓                                              |   |        |        |
| Results Ack                     | ✓                                              |   |        |        |
| Request Sub-Configuration Index | ✖                                              |   | Output | Set Up |
| ---                             | ---                                            |   |        |        |
| Trigger Ready                   | ✓                                              |   |        |        |
| Results Ready                   | ✓                                              |   |        |        |
| Results OK                      | ✓                                              |   |        |        |
| Results NG                      | ✓                                              |   |        |        |
| Classification                  | ✓<br /><br />(if using a Classification model) |   |        |        |
| Error                           | ✓                                              |   |        |        |
| Error Code                      | ✖                                              |   |        |        |
| Online/Ready                    | ✓                                              |   |        |        |
| Heartbeat                       | ✖                                              |   |        |        |
| Busy                            | ✓                                              |   |        |        |
| Current Sub-Configuration Index | ✖                                              |   |        |        |

### Example Workflow

1. LandingEdge indicates that it is **Online**.
2. LandingEdge is ready and asserts **Trigger Ready** (True).
3. The PLC asserts **Trigger** (True) based on the set configurations. LandingEdge receives this signal and recognizes it is time to take an image.
4. LandingEdge changes **Trigger Ready** to False. The PLC receives this signal and recognizes that LandingEdge acknowledged the **Trigger**.
5. LandingEdge asserts **Busy** (True) to indicate that it cannot be triggered again. The PLC can monitor this signal.
6. After LandingEdge has received and processed an image, **Result OK** is set to True and **Result NG** is set to False.
   * If using a Classification model, **Classification** is set to the predicted Class ID.
   * If an error occurs, **Error** is set to True.
7. After the Results are set, LandingEdge asserts **Results Ready** (True) to indicate that results are available for the PLC to read.
8. The PLC recognizes that **Results Ready** or **Error** is set to True.  It reads the appropriate values—like **Results OK** , **Results NG**, and **Classification**—to determine the final prediction from the model.
9. After the PLC reads the results, it asserts **Results Ack**. LandingEdge receives this signal and recognizes that the PLC has read the results and the cycle is complete.
10. LandingEdge resets the result signals and is ready to initiate the cycle again (starting from step 2).

## Sample Script: Read Inputs and Write Outputs

You can add [Results Processing](./custom-processing) scripts to any LandingEdge inspection point, including inspections with PLCs. When running inference with a PLC, you can use the `ReadInput` and `WriteOutput` methods to customize processing based on custom signals defined in the [Inputs](./plc-workflow#inputs) and [Outputs](./plc-workflow#outputs).

The scripts in this section show examples of how you can use these methods:

* `ReadInput`: Save inferenced images to directories and filenames based on custom signals defined in the [Inputs](./plc-workflow#inputs) and [Outputs](./plc-workflow#outputs).
* `WriteOutput`: Send the X and Y coordinates of bounding boxes of predicted objects to the PLC (applicable when using an Object Detection model).

In this example, these custom signals were set up in LandingEdge and the PLC application:

* `lot`: This is the lot number for a set of products, and is defined in the PLC.
* `batch`: This is the batch number for a set of products, and is defined in the PLC.
* `x`: This is the x coordinate of the bounding box for a predicted object of interest.
* `y`: This is the y coordinate of the bounding box for a predicted object of interest.

Here is the sample C# script:

```c# theme={null}
public void Run()
{
    // Read inputs for the lot and batch signals from the PLC; the arguments must match the signal names defined in LandingEdge ("lot" & "batch")
    var lotName = ReadInput("lot");
    var batchName = ReadInput("batch");

    // Save images to custom directories & filenames; these override any other settings
    Data.SaveResultsPath = $@"d:\productionImages\{lotName}\{batchName}";
    Data.SaveResultsFilename=$"{lotName}.png";

    // Send the X & Y coordinates to the PLC
    WriteOutput("x", 123.456);
    WriteOutput("y", 789.123);
}
```

Here is the sample Python script:

```python theme={null}
def run(self):
    # Read inputs for lot and batch from the PLC; the arguments must match the signal names defined in LandingEdge ("lot" & "batch")
    lot_name = self.ReadInput("lot")
    batch_name = self.ReadInput("batch")

    # Save images to custom directories & filenames; these override any other settings
    self.Data.SaveResultsPath = rf"d:\productionImages\{lot_name}\{batch_name}"
    self.Data.SaveResultsFilename = f"{lot_name}.png"
    
    # Send the X & Y coordinates to the PLC
    self.WriteOutput("x", 123.456)
    self.WriteOutput("y", 789.123)
```

## Results Processing Considerations

If you add a [Results Processing](./custom-processing) script that pulls data from the PLC application (using `ReadInput`), LandingEdge will use the values the PLC application sent the last time that you acquired an image. If you change a value in the PLC application, you must capture another image to send the updated value to LandingEdge.

For example, let's say you create a `lot` tag in the PLC application and set its value to 40. You then capture an image. At this point, the `lot` value in LandingEdge is 40. Let's say that you now change the `lot` value in the PLC application to 50. If you run the Results Processing script in LandingEdge again without capturing an image, the value will still be 40. Once you capture another image, the value will change to 50.


# Roles and Permissions
Source: https://landinglens.docs.landing.ai/landingedge/roles-and-permissions



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

<iframe title="YouTube video player" />

Often, LandingEdge is deployed to a shared computer, such as a machine on a manufacturing floor. Several users might access both the machine and LandingEdge. To prevent users from accidentally changing Inspection Points or stopping the inspection process, LandingEdge v2.6.45 and later offers Roles to limit who can access different parts of the system:

* **Admin**: Can access and edit all parts of LandingEdge.
* **Engineer**: Can access and edit all parts of LandingEdge except for editing Role permissions.
* **Operator**: Has read-only access.

If LandingEdge has been idle for 15 minutes, the current user is logged out of the Role. You can then enter a password to log in as an Admin or Engineer. Or, you can log in as an Operator, who by default has read-only access.

## Get Started with Roles and Permissions

When you first set up LandingEdge, set up the Roles and permissions:

1. Learn about the Roles and their default permissions in this article.
2. If needed, [change the permissions](./roles-and-permissions#change-role-permissions) for the Roles.
3. [Set the passwords](./roles-and-permissions#set-and-change-role-passwords) for the Admin and Engineer Roles.

## If You Don't Plan on Using Roles

If you don't plan on using Roles—for example, if LandingEdge runs on a computer that only one person has access to—you don’t need to set up passwords or any of the Permissions settings. If you don’t set a password for any of the Roles, you won’t be logged out after the [Idle Time](./roles-and-permissions#change-the-idle-time).

## Permissions

LandingEdge includes these levels of permissions:

* **Role Permissions**: Can edit the permissions for Roles.
* **Start/Stop Inspection Point**: Can start and stop Inspection Points.
* **Configure Inspection Points**: Can create and edit Inspection Points.
* **Settings**: Can edit the [LandingEdge settings](./landingedge-settings), except for Role permissions.

### Default Permissions for Roles

| Role     | Role Permissions | Start/Stop Inspection Point | Configure Inspection Points | Settings |
| -------- | ---------------- | --------------------------- | --------------------------- | -------- |
| Admin    | ✓                | ✓                           | ✓                           | ✓        |
| Engineer | ✖                | ✓                           | ✓                           | ✓        |
| Operator | ✖                | ✖                           | ✖                           | ✖        |

## Set and Change Role Passwords

A password is required to use the Admin and Engineer Roles. Using the Operator Role doesn't require a password, because this Role is read-only.

To set a password for a Role:

1. Click the **Settings** (gear) icon in the top right corner of the LandingEdge homepage.
   <img alt="LE_home_settings" />
2. Click **Change Password**.
3. Select the Role you want to change the password for from the drop-down menu.
4. Click **Change Password**.
   <img alt="roles_pw_1" />
5. Enter the password in the **New Password** and **Confirm Password** fields.
6. Click **Save**.
   <img alt="roles_pw_2" />
7. LandingEdge saves the password.

### Forgot Your Password?

If an Engineer forgets their password, the Admin can [reset it](./roles-and-permissions#set-and-change-role-passwords) for them.

If an Admin forgets their password, contact  to reset it.

## Switch Roles

<Info>If you haven’t set up passwords before you try to switch Roles, LandingLens will prompt you to set up passwords.</Info>
To switch to another Role:

1. Click the **User Menu** in the top right corner of the LandingEdge homepage.
2. Select the Role you want to switch to.
   <img alt="switch_role_1" />
3. Enter the password for the Role in the **Password** field.
4. Click **Sign In**.
   <img alt="switch_role_2" />
5. LandingEdge logs you in as the selected Role.

## Role and Permission Settings

Users with the Admin Role (or any Role granted the **Role Permissions** permission) can change the settings for Roles. To access these settings:

1. Click the **Settings**(gear) icon in the top right corner of the LandingEdge homepage.
   <img alt="LE_home_settings" />
2. Click **Permissions**. View and edit Roles and permissions as needed.
   <img alt="le_permissions_blank" />

### Change the Idle Time

If you’ve set a password for any of the Roles, a session ends (times out) after 15 minutes of inactivity. After that, a user must enter a password to access LandingEdge.

You can change the **Idle Timeout** time, which is the length of time it takes LandingEdge to time out. To do this:

1. Click the **Settings** (gear) icon in the top right corner of the LandingEdge homepage.
   <img alt="LE_home_settings" />
2. Click **Permissions**.
3. Enter the new timeout time (in minutes) in the **Idle Timeout** field.
   <img alt="permissions_idle" />
4. Click **Save**.

### Change the Default Role

When you open LandingEdge, you are signed in as an Admin by default. You can change the default Role. To do this:

1. Click the **Settings** (gear) icon in the top right corner of the LandingEdge homepage.
   <img alt="LE_home_settings" />
2. Click **Permissions**.
3. Select the new default Role from the **Default Role** drop-down menu.
   <img alt="le_permissions_default_role" />
4. Click **Save**.

### Change Role Permissions

To change the permissions assigned to a Role:

1. Click the **Settings** (gear) icon in the top right corner of the LandingEdge homepage.
   <img alt="LE_home_settings" />
2. Click **Permissions**.
3. In the **Roles** and **Permissions** section, update the selected checkboxes.
   <img alt="permissions_roles_perms" />
4. Click **Save**.


# Upload Images to LandingLens without Running Inference
Source: https://landinglens.docs.landing.ai/landingedge/upload-images-to-landinglens-without-running-inference



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

You can use LandingEdge to upload images to a LandingLens project *without* running inference on those images. The images are uploaded to the Deploy page for the project in LandingLens. Images uploaded to the Deploy page can then be added to the project dataset.

This method is particularly helpful if you want to upload images directly from a camera into LandingLens. For example, if you have an industrial camera on a manufacturing line, you can set up an Inspection Point in LandingEdge to capture images from that camera. That way, you don’t need to first download images from the camera and then upload them into LandingLens.

To upload images using LandingEdge without running inference:

1. Open **LandingEdge**.
2. Open or create an Inspection Point.
3. Set up the **Image Source**, **Inspection Start**, and **Cloud Connection** sections. (LandingEdge must be running [online](./manage-inspection-points).)
4. Leave the **Model** section blank.
5. In the **Image Saving** section, select the **Upload Results to LandingLens** checkbox.
   <img alt="LE_upload_no_modle_1" />
6. Click **Save Configuration**.
7. When you're ready to upload images, click **Run Now** and upload the images using the method you selected in the **Image Source** section. For example, if you selected **Folder Watcher**, move the images you want to upload to the folder you selected.
8. To see the images in LandingLens:
   1. Open the project in **LandingLens**.
   2. Click **Deploy**.
   3. In the **Self-Hosted Deployment** section, click the name of the Inspection Point that you created in **LandingEdge**.
   4. The images display.
      <img alt="LE_upload_no_model_2(2)" />


# Troubleshoot Inaccurate Predictions
Source: https://landinglens.docs.landing.ai/landinglens-error-bucket-cheat-sheet



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

<Info>The information in this section is not applicable to Visual Prompting.</Info>

If a model has many False Positives, False Negatives, or a combination of the two, use the troubleshooting tips below to help you improve model performance.

## Model Has Many False Positives and False Negatives

If a model has many False Positives and False Negatives, it’s possible that it is confusing one class for another. This might indicate that the classes are too similar to each other, or that there aren’t enough examples of at least one of the classes in the dataset.

For example, let’s say that you have two classes in your project: **Water Spot** and **Oil Spot**. After training a model, you notice that it locates some water spots but predicts that they are **Oil Spots**.

<img alt="Compare Ground Truth and Predictions" />

### Possible Root Causes and Solutions

The following table lists possible root causes that could lead to this issue. Check which root cause seems likely, and then try the related troubleshooting tips.

| Root Cause                                                           | Troubleshooting Tips                                                                                                                                                                   |
| -------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Images in the dataset are mislabeled.                                | Check if images are labeled correctly, and fix any mislabels.<br /><br />Add details to the [Label Book](./manage-label-book) to help eliminate confusion and get consistent labeling. |
| Model needs more data.                                               | Add and label more images of the classes that the model predicted incorrectly.                                                                                                         |
| There are no visual/distinguishable differences between two classes. | Consider merging the classes, if that makes sense for your use case. For example, if you currently have Water Spot and Oil Spot classes, consider using a class called Defect instead. |

## Model Has Many False Negatives

If a model has many False Negatives (but *not* False Positives), it’s possible that there aren’t enough examples of the classes that it’s failing to detect. You can think of this scenario as the model not predicting anything in an area where *something* should have been identified.

A False Negative means that the model didn’t detect an object. For example, let’s say you have a class called **Crease**. After training a model, you notice that it doesn’t detect Creases.

<img alt="Model Doesn't Detection Creases" />

### Possible Root Causes and Solutions

The following table lists possible root causes that could lead to this issue. Check which root cause seems likely, and then try the related troubleshooting tips.

| Root Cause                                                                                                                              | Troubleshooting Tips                                                                                                                                                                                                                                                                                        |
| --------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Images in the dataset are mislabeled.                                                                                                   | Check if images are labeled correctly, and fix any mislabels.<br /><br />Add details to the [Label Book](./manage-label-book) to help eliminate confusion and get consistent labeling.                                                                                                                      |
| Model needs more data.                                                                                                                  | Add and label more images of the classes that the model didn’t predict.                                                                                                                                                                                                                                     |
| Environmental noise causes labeled regions to blend into non-labeled regions. The model can’t tell the difference between the two.      | Improve the environmental and lighting conditions. For tips, go to [Image Capture Best Practices](./image-best-practices).<br /><br />If you’re using [Custom Training](./custom-training), consider adding or increasing the strength of augmentations that mimic the real-world image capture conditions. |
| Object is too small or not visible after resizing.                                                                                      | Increase the image size or improve the image resolution.                                                                                                                                                                                                                                                    |
| Applicable to [Custom Training](./custom-training): a data augmentation is too strong, and the object to identify is no longer visible. | If you’re using Custom Training, review the augmentation settings. Consider if any could “hide” the object; if so, you can remove that augmentation or decrease its strength.                                                                                                                               |
| The confidence threshold is too high.                                                                                                   | Use a lower confidence threshold if that makes sense for your use case.                                                                                                                                                                                                                                     |

## Model Has Many False Positives

If a model has many False Positives (but *not* False Negatives), it’s possible that there aren’t enough examples of the classes that it’s incorrectly identifying. You can think of this scenario as the model predicting something in an area where *nothing* should have been identified.

A False Positive means that the model detected an object that wasn’t there. For example, let’s say you labeled a few areas of an image. The model then predicts the class in areas that you didn’t label.

<img alt="False Positives" />

### Possible Root Causes and Solutions

The following table lists possible root causes that could lead to this issue. Check which root cause seems likely, and then try the related troubleshooting tips.

| Root Cause                                                                                                                         | Troubleshooting Tips                                                                                                                                                                                                                                                                                        |
| ---------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Images in the dataset are mislabeled.                                                                                              | Check if images are labeled correctly, and fix any mislabels.<br /><br />Add details to the [Label Book](./manage-label-book) to help eliminate confusion and get consistent labeling.                                                                                                                      |
| Model needs more data.                                                                                                             | Add and label more images of the classes that the model predicted incorrectly.<br /><br /> If you have multiple classes, try to have the same number of examples of each class.                                                                                                                             |
| Environmental noise causes labeled regions to blend into non-labeled regions. The model can’t tell the difference between the two. | Improve the environmental and lighting conditions. For tips, go to [Image Capture Best Practices](./image-best-practices).<br /><br />If you’re using [Custom Training](./custom-training), consider adding or increasing the strength of augmentations that mimic the real-world image capture conditions. |
| The confidence threshold is too low.<br />                                                                                         | Use a higher confidence threshold if that makes sense for your use case.<br />                                                                                                                                                                                                                              |


# LandingLens Login
Source: https://landinglens.docs.landing.ai/landinglens-login



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✖</span></td>
    </tr>
  </tbody>
</table>

## Login Types

Users can sign in to LandingLens using an **email address and password**  or **single sign-on** (SSO). There are two types of SSO:

* **Google**: Log in with your Gmail or Google Workspace account.
* **Enterprise**: Log in using SAML protocol through your work email. If your company wants to use Enterprise SSO, all users within your company's organization must log in this way. Reach out to a  representative activate this Enterprise feature.

<Info>If you are a Member of multiple Organizations, you can use one email to log in to each Organization.</Info>

<img alt="Login Options" />

## Sign Up for LandingLens

1. Open LandingLens.
2. Click **Sign Up**.
   <img alt="Sign Up" />
3. Choose how you want to log in:
   1. **Google SSO login**:
      1. Click **Continue with Google**.
      2. Select your email address and default organization. You are automatically signed up for and logged in to LandingLens.
         <img alt="Select Your Organization" />
   2. **Enterprise SSO login**:
      1. Click **Continue with Enterprise SSO**.
      2. Enter your email address in the **Email** field.
      3. Click **Continue with Enterprise SSO**. You are automatically signed up for and logged in to LandingLens.
         <img alt="Log in with SSO" />
   3. **Email and password login**:
      1. Enter your email address in the **Email** field.
      2. Click **Continue with Email and Password**.
         <img alt="Continue with Email and Password" />
      3. An email is sent to your inbox. Open that email and click the link to continue creating your LandingLens account.
      4. LandingLens opens for you to complete your account setup. Enter your name in the **First Name** and **Last Name** fields.
      5. Enter a strong password in the **Password** field. Remember to follow the [password requirements](./passwords).
      6. Review the **Terms of Service** and select the checkbox to acknowledge that you've read it.
      7. Click **Create LandingLens Account**. Your LandingLens account is created.
         <img alt="Create LandingLens Account" />


# LandingLens on Snowflake Release Notes
Source: https://landinglens.docs.landing.ai/landinglens-on-snowflake-release-notes



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✖</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

## May 26, 2025: LandingLens on Snowflake v1\_2.65

&#x20;v1\_2.65 includes the following features:

* [Anomaly Detection](./landinglens-on-snowflake-release-notes#anomaly-detection)
* [Embed-Optimized Models](./landinglens-on-snowflake-release-notes#embedoptimized-models)

### Anomaly Detection

We are excited to announce a new project type in —**Anomaly Detection**!

The Anomaly Detection project type is used to identify deviations from the norm, especially when you have few images of "abnormal" cases. These projects have two built-in classes: **Normal** and **Abnormal**, which you assign to images.

Anomaly Detection models train on Normal images to learn their patterns. The model then flags any deviations as potential anomalies.

To learn more, go to [Anomaly Detection](./anomaly-detection).

<img alt="AD_images_04_07_2025" />

### Embed-Optimized Models

&#x20;now supports building and deploying **embed-optimized models**, which are lightweight, efficient computer vision models designed to run directly on embedded devices.

To create an embed-optimized model, choose one of the following model architectures when running [Custom Training](./custom-training):

* **For Object Detection**: ODEmbedded-\[23M]
* **For Classification**: ConvNextEmbedded-\[16M]

Using these architecture types generates a TensorFlow Lite (TFLite) model ready for embedded deployment. After downloading an embed-optimized model from LandingLens, you can interact with it using TFLite libraries and APIs.

For detailed information and a quickstart guide, go to [Embed-Optimized Models](./edge-ai).

## February 13, 2025: LandingLens on Snowflake v1\_2.49

&#x20;v1\_2.49 includes the following updates:

* [A redesiged confusion matrix](./landinglens-on-snowflake-release-notes#redesigned-confusion-matrix)
* [Support to load up to 10,000 images from stages](./landinglens-on-snowflake-release-notes#sync-up-to-10000-images)

Keep reading to learn more!

### Redesigned Confusion Matrix

The newest version of LandingLens features a redesigned confusion matrix! The new confusion matrix is a table that shows ground truth labels versus model predictions. This new table format empowers you to quickly see what classes the model is predicting correctly, and which ones it might have trouble identifying.

Each cell shows the count of instances that correspond to particular ground truth class-predicted class pair. For example, in the image below, the model correctly predicted the class "Hard Hat" 32 times and misclassified it 2 times.

<img alt="ConfusionMatrix_ModelList_OD" />

#### Where can I see these changes?

All areas that show model performance now include the updated confusion matrix, including:

* [Build tab](./model-settings): Click **View Confusion Matrix** on a model tile to see the confusion matrix for the dataset that the model was trained on.
  <img alt="ModelList_ViewConfusionMatrix" />
* The [Performance Report](./performance-report) shows a confusion matrix for the selected evaluation set.
* The [Compare Models](./compare-models) tool shows side-by-side confusion matrices to show how each model performed on the selected evaluation set.

#### Learn How to Analyze Models

Watch the following video to learn how to use the updated confusion matrix and other tools to analyze model performance.

<iframe title="YouTube video player" />

### Sync Up to 10,000 Images

When using the [Sync Snowflake Data](./load-images-from-snowflake) workflow, you can now load up to 10,000 images from a Snowflake stage into a LandingLens project. Previously, the maximum was 1,000 images. For more information about loading images from stages, go to [Load Images from Snowflake into LandingLens](./load-images-from-snowflake).

## January 30, 2025: LandingLens on Snowflake v1\_2.47

, previously only available in AWS regions, is now available in Azure regions. This expansion allows you to deploy LandingLens in your preferred region. All LandingLens features are the same across all regions.

For detailed information about region support for Snowflake Native Apps, go to the [Snowflake documentation](https://docs.snowflake.com/en/developer-guide/native-apps/limitations).

## January 15, 2025: LandingLens on Snowflake v1\_2.45

In  v1\_2.45, you can now create and restore backup versions of the application!

Having backup versions of the LandingLens application can be helpful if data is deleted that needs to be later recovered. For example, if a project in LandingLens is accidentally deleted, you can restore an earlier version of LandingLens that has that project. Additionally, if the LandingLens app is deleted, you can restore a backed up version.

To get the full details, go to [Back Up and Restore LandingLens on Snowflake](./back-up-and-restore-landinglens-on-snowflake).

## December 2, 2024: LandingLens on Snowflake v1\_2.42

In  v1\_2.42, we've expanded the ability to manage CPU resources used by the app. When configuring the **Installation Size** setting, which controls the number of CPU machines and service replicas used by the LandingLens app, you now have a new option: **xlarge**. This is now the largest option, and is 5x times the size of the smallest option (POC).

Additionally, the default Installation Size option is now **medium**. This does not change the selected Installation Size for any current instances of LandingLens.

For more information about how to manage CPU and GPU resources, go to [Snowflake Credit Management](./credit-management).

<img alt="installation_size_v1_2_42" />

### Upgrading Is Now Easier

When a new version of  is available, a button now displays in the top right corner of the app with this text: "Upgrade to \[current\_version]."

Click the button to launch the app installer in Snowsight. For more information about how to upgrade the app, go to [Install and Upgrade LandingLens on Snowflake](./install-landinglens-in-snowflake).

<img alt="upgrade_app_v1_2_42" />

## November 21, 2024: LandingLens on Snowflake v1\_2.40

&#x20;v1\_2.40 includes these updates:

* [End Model Training](./landinglens-on-snowflake-release-notes#end-model-training)
* [More Ways to Manage CPU and GPU Resources](./landinglens-on-snowflake-release-notes#more-ways-to-manage-cpu-and-gpu-resources)
* [TIF/TIFF upload support](./landinglens-on-snowflake-release-notes#upload-tiftiff-files-to-projects)
* [Dataset snapshot CSVs now include tags](./landinglens-on-snowflake-release-notes#dataset-snapshot-csvs-now-have-image-tags)

### End Model Training

You can now end model training early. To do this, click **End Training Now** on the model tile. For example, if you click **Train** and then realize you need to annotate more images, you can click **End Training Now**, label those images, and then start a new training job.

For details about model training, including how to end training early, go to [Model Training](./train-models).

<img alt="endTrain_11_22_2024_1" />

<img alt="endTrain_11_22_2024_2" />

### More Ways to Manage CPU and GPU Resources

We've added more ways to manage the CPU and GPU resources used by . In addition to enabling Auto-Suspend GPU, you can now select the Installation Size (the number of CPU machines and replicas used by the app) and the number of GPU training resources.

For full details about how to manage CPU and GPU resources, go to [Snowflake Credit Management](./credit-management).

<img alt="LLSF_configs_11_22_2024" />

### Upload TIF/TIFF Files to Projects

TIF/TIFF files can now be uploaded to projects in . However, LandingLens models cannot run inference on TIF/TIFF files.

To learn more about image support, including supported image files and maximum image size, go to [Upload Images](./upload-images).

### Dataset Snapshot CSVs Now Have Image Tags

When you download a CSV for a [dataset snapshot](./dataset-snapshots), the CSV now lists any tags applied to the images.

To learn more about dataset snapshots, go to [Dataset Snapshots](./dataset-snapshots).

<img alt="snapshot_tags" />

## October 31, 2024: Download CSV of Model Performance

You can now download a CSV of model performance for select images in your Object Detection or Classification dataset. The prediction data in the CSV will be based on the selected model and confidence threshold (if you manually change the threshold, that threshold is used in the CSV).

For detailed instruction on how to download the CSV, go to [Model Reports](./model-settings#download-csv-model-predictions-for-select-images).

<img alt="DownloadCSV_SelectImages_1" />


# Get Started with LandingLens
Source: https://landinglens.docs.landing.ai/landinglens-overview



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

<iframe title="YouTube video player" />

LandingLens is a cloud-based computer vision platform. LandingLens empowers you to create and train computer vision models—even if you don't have a background in AI, machine learning, or computer vision. LandingLens guides you through the process of uploading images, labeling them, training models, comparing model performance, and finally—deploying models.

To support users who are familiar with machine learning, LandingLens includes advanced tools to customize the model training process. LandingLens also supports advanced deployment options via [Docker](./landingedge/docker-deploy) and [LandingEdge](./landingedge/landingedge-overview), our edge-deployment solution.

## Continuous Learning

After you're running inference on your model, you can continue to fine-tune it! You can automatically add images that you've run inference on into your dataset in LandingLens, and then retrain your model with that new data. This process of continuous learning ensures that your model and process evolve when you need them to.

<img alt="landingai-illustration" />

## Use Computer Vision Models from LandingLens

After you've trained a model in LandingLens, you can deploy it using a variety of deployment options. Additionally, Developers can use our [Python](https://github.com/landing-ai/landingai-python) and [JavaScript](https://github.com/landing-ai/landingai-js) API libraries to programmatically run inference.

<img alt="ll_overview_deployed" />


# LandingLens Release Notes
Source: https://landinglens.docs.landing.ai/landinglens-release-notes



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✖</span></td>
    </tr>
  </tbody>
</table>

<Update label="September 2, 2026: Per-Sample Report API and Models Page Updates">
  This release adds API access to per-sample prediction data, shows Model IDs on the Models page, and improves the responses from several API endpoints:

  * [Download Per-Sample Prediction Data with the API](./landinglens-release-notes#download-per-sample-prediction-data-with-the-api)
  * [Model IDs Display on the Models Page](./landinglens-release-notes#model-ids-display-on-the-models-page)
  * [Get Active Project Status from the Project List](./landinglens-release-notes#get-active-project-status-from-the-project-list)
  * [Consistent Model Names Across Model Endpoints](./landinglens-release-notes#consistent-model-names-across-model-endpoints)
  * [Clearer Response When a Snapshot Needs Exporting](./landinglens-release-notes#clearer-response-when-a-snapshot-needs-exporting)

  ## Download Per-Sample Prediction Data with the API

  You can now download per-sample prediction data using the API. Previously, this data was only available by clicking **Download CSV** in the LandingLens app.

  The report is a CSV file with one row for each image in the snapshot the model was trained on, covering every split. Each row includes the label you assigned (ground truth) and the model's prediction. For Object Detection and Classification projects, it also includes the model's Confidence Score. This is the same file you get when you [download a CSV of model predictions for the images in a model's dataset](./model-settings#download-csv-model-predictions-for-images-in-a-model-dataset) in the app.

  Use this endpoint to get a download link for the report:

  ```http theme={null}
  GET /v1/projects/{project_id}/train/{training_id}/results/per-sample-report
  ```

  This endpoint supports Object Detection, Classification, and Anomaly Detection projects. It doesn't support Segmentation projects.

  Get more information about this API in [Get Per Sample Report](https://landing-ai.github.io/public-rest-api/fastapi/#/operations/get_per_sample_report_v1_projects__project_id__train__training_id__results_per_sample_report_get). For instructions and a description of the data in the file, go to [Download CSV with the API](./model-settings#download-csv-with-the-api).

  ## Model IDs Display on the Models Page

  The ID of the trained model now displays under the model name on the Models page, with a **Copy** icon next to it. This is the ID you use with the LandingLens API, as `model_id` or `training_id`. For instructions, go to [Get the Model ID for the API](./models-page#get-the-model-id-for-the-api).

  ## Get Active Project Status from the Project List

  This endpoint now returns the `isActive` value for each project:

  ```http theme={null}
  GET /v1/projects
  ```

  Previously this value was empty, so you had to call `GET /v1/projects/{project_id}` once per project to find out which project was active. You can now get this in a single call.

  Get more information about this API in [Get Projects](https://landing-ai.github.io/public-rest-api/fastapi/#/operations/get_projects_v1_projects_get).

  ## Consistent Model Names Across Model Endpoints

  This endpoint now returns the model name you assigned in LandingLens:

  ```http theme={null}
  GET /v1/projects/{project_id}/models/{model_id}
  ```

  Previously it returned an internal training job name, which didn't match the name returned by `GET /v1/projects/{project_id}/models`. Both endpoints now return the same name for the same model.

  This endpoint now also returns a `404` response when a model doesn't exist, was deleted, or didn't train successfully. Previously it returned a `200` response with an error message in the body. If your application checks the response body to detect these cases, check the status code instead.

  ## Clearer Response When a Snapshot Needs Exporting

  A snapshot has to be exported before you can download it. When you request a download link for a snapshot that hasn't been exported, these endpoints now return a `404` response that tells you to export the snapshot first:

  ```http theme={null}
  GET /v1/projects/{project_id}/dataset/snapshots/{snapshot_version}/export
  GET /v1/projects/{project_id}/dataset/snapshots/{snapshot_version}/metadata
  ```

  Each endpoint previously returned a different message that didn't explain what to do next.

  For instructions on exporting and downloading a snapshot with the API, go to [Export a Snapshot with the API](./dataset-snapshots#export-a-snapshot-with-the-api).
</Update>

<Update label="March 31, 2026: Smart Labeling Now Uses SAM 2">
  ## Smart Labeling Now Uses SAM 2

  The  tool has been updated to use [SAM 2](https://ai.meta.com/research/sam2/), the latest version of Meta's open-source Segment Anything Model. This update improves segmentation accuracy, so Smart Labeling detects object boundaries more precisely.

  For more information, go to [Label with Smart Labeling](/segmentation#label-with-smart-labeling).
</Update>

<Update label="March 3, 2026: LandingLens and LandingEdge Documentation Has Moved">
  ## LandingLens and LandingEdge Documentation Has Moved

  Documentation for LandingLens and LandingEdge has moved to this site, [landinglens.docs.landing.ai](https://landinglens.docs.landing.ai/).

  Existing links to docs.landing.ai/landinglens and docs.landing.ai/landingedge will automatically redirect to this new site.
</Update>

<Update label="January 29, 2026: Organize Projects with Folders">
  ## Organize Projects with Folders

  You can now create folders to organize your projects within your organization. Use folders to build a hierarchical structure that suits your workflow.

  With folders, you can:

  * Create nested folders to organize projects
  * Move projects between folders
  * Search within a specific folder or across all projects
  * Navigate through folders using breadcrumb navigation

  All organization members can view folders. Collaborators can move their own projects into folders. Admins and Owners can create, move, rename, and delete folders.

  To learn more about managing projects and folders, go to [Manage Projects](./create-projects).
</Update>

<Update label="July 28, 2025: Changes to Classic Flow Support">
  ## LandingEdge & Docker Deployment v2.11.81 Are Final Versions to Support Classic Flow Models

  We are announcing that the last version of LandingEdge and Docker deployment that supports Classic Flow models is v2.11.81. Future versions will not support Classic Flow models.

  For detailed information, go to [Classic Flow](./classic-flow).
</Update>

<Update label="May 29, 2025">
  ## More Granular Project Access Management

  We’ve made two important updates to project access management for organizations on the **Enterprise** plan:

  * **New Project Access Page**: Owners can now view and manage access to all projects—public and private—through a new Project Access page. This gives Owners greater visibility and control, which is especially useful when reassigning private projects if a project Owner leaves the organization. To get the details, go to [Manage Project Access](./override-project-access).
  * **More Owners Per Organization**: Previously, organizations could only have 3 Owners. We've removed that maximum, so you can now have multiple Owners. This gives your organization greater flexibility to manage access.
</Update>

<Update label="May 5, 2025">
  ## Embed-Optimized Models

  LandingLens now supports building and deploying **embed-optimized models**, which are lightweight, efficient computer vision models designed to run directly on embedded devices.

  To create an embed-optimized model, choose one of the following model architectures when running [Custom Training](./custom-training):

  * **For Object Detection**: ODEmbedded-\[23M]
  * **For Classification**: ConvNextEmbedded-\[16M]

  Using these architecture types generates a TensorFlow Lite (TFLite) model ready for embedded deployment. After downloading an embed-optimized model from LandingLens, you can interact with it using TFLite libraries and APIs.

  For detailed information and a quickstart guide, go to [Embed-Optimized Models](./edge-ai).
</Update>

<Update label="April 7, 2025">
  ## Anomaly Detection

  We are excited to announce a new project type in LandingLens—**Anomaly Detection**!

  The Anomaly Detection project type is used to identify deviations from the norm, especially when you have few images of "abnormal" cases. These projects have two built-in classes: **Normal** and **Abnormal**, which you assign to images.

  Anomaly Detection models train on Normal images to learn their patterns. The model then flags any deviations as potential anomalies.

  To learn more, go to [Anomaly Detection](./anomaly-detection).

  <img alt="AD_images_04_07_2025" />
</Update>

<Update label="February 11, 2025">
  ## Updated Confusion Matrix

  The newest version of LandingLens features a redesigned confusion matrix! The new confusion matrix is a table that shows ground truth labels versus model predictions. This new table format empowers you to quickly see what classes the model is predicting correctly, and which ones it might have trouble identifying.

  Each cell shows the count of instances that correspond to particular ground truth class-predicted class pair. For example, in the image below, the model correctly predicted the class "Hard Hat" 32 times and misclassified it 2 times.

  <img alt="ConfusionMatrix_ModelList_OD" />

  ### Where can I see these changes?

  All areas that show model performance now include the updated confusion matrix, including:

  * [Build tab](./model-settings): Click **View Confusion Matrix**on a model tile to see the confusion matrix for the dataset that the model was trained on.
    <img alt="ModelList_ViewConfusionMatrix" />
  * The [Performance Report](./performance-report) shows a confusion matrix for the selected evaluation set.
  * The [Compare Models](./compare-models) tool shows side-by-side confusion matrices to show how each model performed on the selected evaluation set.

  ### Learn How to Analyze Models

  Watch the following video to learn how to use the updated confusion matrix and other tools to analyze model performance.

  <iframe title="YouTube video player" />
</Update>

<Update label="December 2, 2024">
  ## End Model Training, TIFF Support, and More

  We're excited to release these updates to LandingLens:

  * [Improved workflow for ending model training early](./landinglens-release-notes#changes-to-ending-model-training)
  * [TIF/TIFF upload support](./landinglens-release-notes#upload-tiftiff-files-to-projects)
  * [Dataset snapshot CSVs now include tags](./landinglens-release-notes#dataset-snapshot-csvs-now-have-image-tags)

  ### Changes to Ending Model Training

  We've made it easier to end model training early. Previously, model training could only be stopped during the **Training & learning** step, and LandingLens would evaluate the images in your dataset with the model it had generated up to that point.

  Now, you can end model training at any point. The model tiles for these training jobs display the text **Manually Ended** so that there is a record that model training started, but wasn't completed. To prevent users from accidentally using incomplete models, LandingLens no longer generates models when training is manually ended.

  To learn more about training models, go to [Train Models](./train-models).

  <img alt="endTrain_11_22_2024_1" />

  <img alt="endTrain_11_22_2024_2" />

  ### Upload TIF/TIFF Files to Projects

  TIF/TIFF files can now be uploaded to LandingLens projects. However, LandingLens models cannot run inference on TIF/TIFF files.

  To learn more about image support, including supported image files and maximum image size, go to [Upload Images](./upload-images).

  ### Dataset Snapshot CSVs Now Have Image Tags

  When you download a CSV for a [dataset snapshot](./dataset-snapshots), the CSV now lists any tags applied to the images.

  To learn more about dataset snapshots, go to [Dataset Snapshots](./dataset-snapshots).

  <img alt="snapshot_tags" />
</Update>

<Update label="October 31, 2024">
  ## Download CSV of Model Performance

  We just released a new version of LandingLens with these features:

  * [Download a CSV of model performance for select images](./landinglens-release-notes#download-csv-of-model-performance-for-select-images)
  * [Hide LandingEdge and Docker deployment options](./landinglens-release-notes#hide-landingedge-and-docker-deployment-options)

  ### Download CSV of Model Performance for Select Images

  You can now download a CSV of model performance for select images in your Object Detection or Classification dataset. The prediction data in the CSV will be based on the selected model and confidence threshold (if you manually change the threshold, that threshold is used in the CSV).

  For detailed instruction on how to download the CSV, go to [Model Reports](./model-settings#download-csv-model-predictions-for-select-images).

  <img alt="DownloadCSV_SelectImages_1" />

  ### Hide LandingEdge and Docker Deployment Options

  For Enterprise users,  can now hide the LandingEdge and LandingAI deployment options if you don't want your organization to deploy using these methods. To have these disabled, contact [support@landing.ai](mailto:support@landing.ai).
</Update>

<Update label="July 8, 2024">
  ## New Model Analysis Interface & Training APIs

  We've streamlined the experience for viewing and analyzing model performance right after training a model! We've moved around a few elements on the **Build** page and surfaced key model performance metrics. The goal of these updates is to quickly give you the data you need to decide if you need to finetune your model before deploying it.

  Here's an overview of the updated model performance tools on the Build page. Want a deeper dive on these features? Check out [View Predictions](./view-predictions) and [Model Reports](./model-settings)!

  | # | Description                                                                                                                                                                                                                                                                                                                                                          |
  | - | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
  | 1 | Turn on and manage Predictions all in one place!<br /><br />When you turn on **Predictions**, you can now select the model and confidence threshold you want to see predictions for. Get more details in [View Predictions](./view-predictions).                                                                                                                     |
  | 2 | Click **Try Model** to see how the model performs on new images. This is the same as the "Predict" button in previous versions of LandingLens.                                                                                                                                                                                                                       |
  | 3 | Key model performance data now displays on **model tiles**. You can now see a few model tiles at a time, so that you can compare model performance at a glance.<br /><br />The model tile shows the model's F1 or IoU score for each data split (Train, Dev, and Test) and the number of Correct, False Positive, False Negative, and Misclassification predictions. |
  | 4 | Clicking a model tile opens a window with detailed performance data and a confusion matrix. You can toggle between the F1 or IoU, Precision, and Recall scores. Get more details in [Model Reports](./model-settings).                                                                                                                                               |

  ### LandingLens APIs

  You can now retrieve a model's training metrics and confusion matrix using the [LandingLens API](https://landing-ai.github.io/public-rest-api/fastapi/#/). To learn more about how to use these training APIs, see this [Training Metrics tutorial](https://landing-ai.github.io/public-rest-api/tutorial/training/metrics/).

  #### Model Training Metrics

  The training metrics include the Performance, Recall, and Precision scores for the model. Use this endpoint to get a model's training metrics:

  `/v1/projects/{project_id}/train/{training_id}/results/metrics`

  Get more information about this API in [Get Metrics Summary](https://landing-ai.github.io/public-rest-api/fastapi/#/operations/get_metrics_summary_for_all_splits_v1_projects__project_id__train__training_id__results_metrics_get).

  #### Model Confusion Matrix

  The confusion matrix lists the number of correct predictions, false negatives, false positives, and misclassifications. Use this endpoint to get a model's confusion matrix:

  `v1/projects/{project_id}/train/{training_id}/results/confusion-matrix`

  Get more information about this API in [Get Confusion Matrix For All Splits](https://landing-ai.github.io/public-rest-api/fastapi/#/operations/get_confusion_matrix_for_all_splits_v1_projects__project_id__train__training_id__results_confusion_matrix_get).
</Update>

<Update label="June 6, 2024">
  ## Use Label Assist to Improve Model Performance

  We just released a new version of LandingLens that includes these two exciting features:

  * [Label Assist](./landinglens-release-notes#label-assist)
  * [Download CSVs from Evaluation Sets](./landinglens-release-notes#download-csvs-from-evaluation-sets)

  ### Label Assist

  We've introduced a new tool called **Label Assist** that suggests new labels or improvements to labels! Use Label Assist to speed up the labeling process and help make your labels ("ground truth" annotations) more accurate, so that the next model will have better performance.

  Label Assist can spot missing labels and suggest label improvements. For example, if there's a large space between an object and the original bounding box, Label Assist might suggest a tighter label.

  Label Assist shows you its suggestions on the image details page as dashed bounding boxes. Click a suggestion to accept it, or click **Accept All** to accept all suggestions for an image. After reviewing and accepting suggestions, train the model again to include the newest labels in a model. For detailed information, check out the full article here: [Label Assist](./label-assist).

  <img alt="LabelAssist_Overview" />

  <Info>Label Assist replaces another tool called Check Label Quality. That feature has been deprecated.</Info>

  ### Download CSVs from Evaluation Sets

  When looking at an evaluation set's [Performance Report](./compare-models), you can now download a CSV of information about the images in that evaluation set. The CSV includes several data points for each image, including the labels ("ground truth") and model's predictions. The CSV download is available for Object Detection and Classification projects.

  For more information, go to [Download CSV of Evaluation Set](./performance-report#download-csv-of-evaluation-set).

  <img alt="PerformanceReport_DownloadCSV" />
</Update>

<Update label="May 24, 2024">
  ## LandingLens API

  We now offer a [LandingLens API](https://landing-ai.github.io/public-rest-api/fastapi/#/)! The LandingLens API is a RESTful API that allows you to use LandingLens programmatically. You can use the LandingLens API to perform many tasks, including:

  * Create projects
  * Upload images to projects
  * Create classes
  * Train models
  * Deploy models to cloud-endpoints hosted by  (cloud deployment).

  Access the LandingLens API [here](https://landing-ai.github.io/public-rest-api/fastapi/#/).
</Update>

<Update label="May 6, 2024">
  ## Simplified Pricing Plans, Model Downloads, and More!

  We’re simplifying our LandingLens plans to offer more capabilities and an easy-to-understand pricing structure! You can check out all the details on our [Pricing](https://landing.ai/pricing) page, but the most game-changing updates are that all users can now:

  * Use [LandingEdge](./landingedge/landingedge-overview), our edge deployment solution.
  * Use [Docker Deployment](./landingedge/docker-deploy), which empowers you to run model inference programmatically.
  * [Download models](./download-models) from LandingLens! You can load the models to LandingEdge or Docker to deploy offline, or you can use the ONNX file to deploy the model via your own app.

  Keep reading and watch the video below to get more details about these updates and how you can leverage them.

  <iframe title="YouTube video player" />

  ### Use LandingEdge & Docker Deployment Today—No Licenses Needed!

  In an effort to make it as easy as possible to deploy your LandingLens model, [LandingEdge](./landingedge/landingedge-overview) and [Docker Deployment](./landingedge/docker-deploy) are now available to users on all pricing plans.

  Plus, we’ve removed the requirement to have a license to run LandingEdge and Docker Deployment. You can now download and run these tools without getting a license from .

  If you have an older version of LandingEdge and Docker Deployment, download the latest versions to leverage the “no-license” benefit.

  ### Download Models

  You can now download your computer vision model from LandingLens! The model is downloaded as a ZIP file that you can load directly into LandingEdge and Docker Deployment if you want to deploy offline.

  The downloaded model also includes the ONNX file for the model. ONNX (Open Neural Network Exchange) is an open source format for AI models, so you can use your model in your own custom applications.

  Only Enterprise users can use downloaded models for commercial purposes. Models downloaded from the Free and Visionary plans can only be used for noncommercial use.

  ### Workflow for Downloading Models

  This new version of LandingLens introduces the concept of “[activated projects](./activate-projects)”. You must activate a project before you can [download models](./download-models) from it or deploy models from it using LandingEdge or Docker Deployment. Each pricing plan has a maximum number of projects that can be active at the same time:

  * **Free**: 1 project
  * **Visionary**: 3 projects
  * **Enterprise**: Starts at 5 projects

  Projects are activated in a new page called **Active Projects**. For detailed instructions about how to activate and deactivate projects, go to [Activate Projects](./activate-projects).

  <img alt="activate_project_4" />

  After you activate a project, you can download as many models from the project as you like. Models are downloaded from the **Models** tab.

  <img alt="download_model_2024" />

  ### New Credit Calculation for Custom Training

  In addition to changing the LandingLens pricing plans, we’re also changing how credits are charged for [Custom Training](./custom-training). Each LandingLens plan includes a set of credits, which are like a form of currency in LandingLens. You spend credits to train models and run inferences.

  Until now, training one image cost 1 credit, and running inference on one image cost 1 credit. As of today (May 6, 2024), the credit cost for Custom Training is now calculated differently. The credit cost is now based on the project type and custom training settings selected. In general, increasing any of the settings (like increasing the Epoch) increases the cost to train and run inference.

  With Custom Training, the cost to train the model and run inference on that model might be more or less than 1 credit.

  After you configure your settings—and before you train the model—LandingLens shows you the exact credit cost it will take to train the model and run inference on it.

  <img alt="custom_train_2024_5(1)" />

  <Info>There are no changes to how credits are calculated for Fast Training (the default training method). Training an image and running inference on an image will continue to cost 1 credit each.</Info>

  ### Each Model Can Have a Different Inference Cost

  If you run Custom Training multiple times in the same project, each resulting model can have a different cost for running inference. This is because each round of Custom Training can have multiple different settings, each of which impact the cost.

  For example, you could have three models with the following inference costs in the same project:

  | Model   | Training Type                           | Credit Cost for Inference |
  | ------- | --------------------------------------- | ------------------------- |
  | Model A | Fast Training (default training method) | 1 credit / image          |
  | Model B | Custom Training                         | 1.62 credits / image      |
  | Model C | Custom Training                         | 0.35 credits / image      |
</Update>

<Update label="April 18, 2024">
  ## April 18, 2024

  Computer vision models are trained based on sets of labeled images called *splits*. The three splits are the Train set, Dev set, and Test set. During the model training process, the model uses the splits to learn patterns, validate its predictions, and test its accuracy. Images in each split must be labeled in order for the model to learn what data is and isn’t relevant to each class.

  LandingLens offers many ways to assign splits to images, including assigning splits when uploading images. Before this release, splits could be assigned at upload even if some images weren’t labeled. Now, to help you manage splits more accurately, a split can only be assigned at upload if those images are labeled. To learn all about splits in LandingLens, go to [Splits](./splits).

  <img alt="split_upload" />
</Update>

<Update label="April 2, 2024">
  ## April 2, 2024

  We just released a new version of LandingLens that features a new tool: [Compare Models](./compare-models)! The Compare Models tool is a great way to evaluate performance on multiple iterations of the model. It can help you identify if you need to improve your labels, datasets, and hyperparameters.

  When you run the Compare Models tool, you set a **baseline** model and a **candidate** model. LandingLens then shows you if the candidate model performed better or worse for each prediction outcome (False Positive, False Negative, Correct, etc). You can even see a side-by-side comparison of how the baseline and candidate models performed on each image in the dataset. To get the full details about how to use the Compare Models tool, go to [Compare Models](./compare-models).

  <img alt="CompareModels_overview" />
</Update>

<Update label="March 18, 2024">
  ## March 18, 2024

  A new version of LandingLens is now available! This version includes some small (but mighty!) enhancements that can streamline your workflow. These improvements include:

  * You can now train up to 10 models at once.
  * We’ve added a safeguard to Custom Training that ensures that crops are only applied after resizes or rescales. For more information about cropping during Custom Training, go [here](./custom-training).
  * Model names can now include special characters.

  ### Bug Fixes

  This release of LandingLens includes the following bug fixes:

  * When using the Auto Split tool, the lines for each class align with the percentages on the right side of the page. Previously, the alignment was off.
    <img alt="AutoSplit_lines" />
  * The Deploy page for Classification projects no longer shows a Confidence Score. LandingLens only uses a Confidence Score for Object Detection and Segmentation projects.
</Update>

<Update label="March 12, 2024">
  ## March 12, 2024

  In the new release of LandingLens, a **Validation Chart** now displays on the **Training Information** tab for a model.

  <img alt="validation_chart" />

  The Validation chart is calculated on the Dev split. This chart displays when the model was trained using [Custom Training](./custom-training) and the Dev split has at least 6 images.

  If the model improves during the validation process, the line goes up over time. The line will look slightly different for each project type because each uses a different validation metric:

  * **Object Detection**: mAP (Mean Average Precision)
  * **Segmentation**: mIoU (mean Intersection over Union)
  * **Classification**: F1 score

  For more information about a model's Training Information, go to [Analyze and Compare Models](./compare-models).
</Update>

<Update label="February 29, 2024">
  ## February 29, 2024

  The newest version of LandingLens introduces more Model Size options for Custom Training. The Model Size refers to the architecture and number of parameters used to train the model.

  We’ve added a third model size option to Object Detection projects: **RtmDet-\[9M]**. This option leads to the fastest training and inference times, when compared to the other two model sizes. This model size uses the [RTMDet](https://arxiv.org/abs/2212.07784) architecture and 9 million parameters.

  For detailed information about creating custom-trained models in LandingLens, go to [Custom Training](./custom-training).
</Update>

<Update label="February 21, 2024">
  ## February 21, 2024

  The latest version of LandingLens features a redesigned process for Custom Training! You now have greater control over the dataset and splits used during the training process. Additionally, the user interface now guides you more clearly through configuring the training settings.

  All of the transforms and augmentations from the previous design are still available. Additionally, the new process does not impact any models you’ve already developed.

  The following sections highlight some new key points in Custom Training. To learn all the details, go to [Custom Training](./custom-training).

  <img alt="custom_training_2024_nocredits_overview" />

  ### Select a Dataset

  In previous versions of LandingLens, the Custom Training process would automatically apply to the dataset currently in the **Build** tab. Or, you could go to the Dataset Snapshots module, select a dataset, and then start Custom Training.

  When you click **Custom Training** in the new process, you’re now first prompted to select a dataset. This speeds up the process and shows you all of your options in one place.

  <img alt="custom_train_2024_2_SetUpYourData" />

  ### Set Up Splits

  If you choose to run Custom Training on the dataset currently in the Build tab, and those labeled images don’t have splits assigned to them yet, you can assign splits during Custom Training.

  You can assign splits based on all images in the dataset or based on each class.

  <img alt="custom_train_2024_3_Splits" />

  ### Train Multiple Models for the Same Dataset at Once

  You can now configure multiple sets of training parameters for the same dataset at once. This is helpful when you want to see how changing a parameter–like the number of epochs–will affect the model. By setting up all training parameters at once, you don’t need to go through the Custom Training process multiple times.

  To add another set of training parameters, click **Add Another Model** or **Duplicate**.

  <img alt="custom_train_addmodel_nocredits" />
</Update>

<Update label="January 30, 2024">
  ## January 30, 2024

  In this release, we’ve introduced three significant updates to streamline your computer vision model creation process.

  First, we’ve made it much easier to [compare and analyze model performance](./landinglens-release-notes#compare-models). All models for a project are now centralized on a new page called Models, which allows you to compare model performance across different datasets.

  Second, we’ve [updated Segmentation projects](./landinglens-release-notes#updated-segmentation-projects) to offer more flexibility and faster inference speeds.

  And finally, we’ve [redesigned the labeling experience](./landinglens-release-notes#redesigned-labeling-experience) for Object Detection, Segmentation, and Classification projects.

  Keep reading to get more details about these updates!

  ### Compare Models

  You can now quickly and easily compare model performance across multiple datasets in a single project.

  All trained models for a project now appear in a table on a new tab called **Models**. By default, you can see how each model performed on its Train, Dev, and Test sets. You can also add existing dataset snapshots—or filtered versions of them—to the table. This matrix empowers you to quickly compare model performance on a variety of datasets. From here, you can also deploy models.

  Comparing model performance on the **Models** tab isn't a required step in LandingLens, but it's a useful technique for identifying your most accurate models. For full details, go to [Compare Models](./compare-models).

  <img alt="modelspage_home" />

  <Info>Due to the unique nature of [Visual Prompting](./visual-prompting), the Models tab is not available for Visual Prompting projects.</Info>

  #### Impacts to Cloud Deployment

  We anticipate that most users will want to compare mode performance in the **Models** tab before choosing which model to deploy. Because of this, the Cloud Deployment process now starts from the **Models** tab. After comparing the models in the table, simply click the **Rocket** (deploy) icon for the model you want to deploy. The rest of the deployment process is the same as before.

  <img alt="CloudDeployment_01_2024" />

  We’ve made two additional changes to Cloud Deployment to ensure more consistent comparisons between endpoints:

  * Once a model is deployed to an endpoint, that model can’t be swapped for another.
  * The Confidence Threshold of a deployed model can’t be changed.

  ### Updated Segmentation Projects

  As part of this release, the Segmentation projects in your LandingLens organization have new capabilities, including:

  * You can upload up to 10,000 images to a Segmentation project.
  * When using Custom Training for Segmentation projects, you can now resize images to be up to 1024x1024px.
  * Running inference on models trained via Custom Training will now be faster.
  * Updated Model Size options in Custom Training. Keep reading for more information.

  #### Updated Model Sizes in Custom Training

  When using Custom Training, you can now choose from these two model sizes:

  * **FastViT-\[14M]**: Train and run inferences faster. Uses the [FastViT](https://arxiv.org/abs/2303.14189) transformer architecture and 14 million parameters.
  * **SegFormer-\[14M]**: Capture more complex patterns in the training data. Training and running inferences will take longer. Uses the [SegFormer](https://arxiv.org/abs/2105.15203) semantic segmentation framework and 14 million parameters.

    <img alt="modelSize_Seg" />

  ### Redesigned Labeling Experience

  In this release, the label view now has a brand-new look, offering a more modern and intuitive interface while maintaining all existing tools and functionalities for Object Detection, Segmentation, and Classification. For more information, go to [Labeling](./labeling).

  Here’s what you can expect the label view page to look like for each project type:

  **Object Detection**

  <img alt="Object Detection" />

  **Segmentation**

  <img alt="Segmentation" />

  **Classification**

  <img alt="Classification" />
</Update>

<Update label="December 19, 2023">
  ## Train Multiple Models at Once

  When one model is training, you can now start training another model! This is helpful if you want to compare performance between multiple datasets or model training settings. Training multiple models at once is sometimes called "parallel training".

  Parallel training is available for both the [Fast Training](./train-models) and [Custom Training](./custom-training) methods.

  Let’s say you want to build two models for the same dataset using Custom Training. You want one model to use 30 epochs and the other to use 40 epochs. You can start training the second model without waiting for the first one to complete. This capability empowers you to run experiments faster.

  To see the status of a model, click the **Models** drop-down menu. Models that are still training have the status **In Progress**.

  <img alt="parallel_train" />

  ### Bug Fixes

  In previous versions of LandingLens, training a [Visual Prompting](./visual-prompting) model sometimes led to inaccurate predictions and this error message:

  “Model training failed. Please try training a new model.”

  This bug has been fixed, and Visual Prompting models now train correctly.
</Update>

<Update label="December 4, 2023">
  ## December 4, 2023

  We have great news for our LandingEdge and Docker users! As of today, you no longer need to deploy a model via [Cloud Deployment](./cloud-deployment) (or by generating a deployable version of a model) to use that model in LandingEdge and Docker.

  All models trained starting today will automatically be deployable via LandingEdge and Docker! Each model has its best Confidence Score. To see all models that can be deployed from a project, go to **Deploy** and click **Deployable Models**.

  <img alt="deployable_models_12_2023" />

  If you want to use a different Confidence Score for a model, or if you don't see your model in the Deployable Models table, you can either deploy it via [Cloud Deployment](./cloud-deployment) or use the following procedure to generate a deployable model:

  1. Open the project with the model you want to deploy.
  2. Click **Models** to open the Models panel.
     <img alt="deployable_model_1" />
  3. Select the model you want to deploy from the **Model** drop-down menu.
  4. Use the **Confidence Threshold** slider to select the Confidence Score you want the model to have.
  5. Click **Deploy**.
     <img alt="deployable_model_2_deploy" />
  6. Select **Self-Hosted Deployments**.
  7. Click **Generate Deployable Model**.
     <img alt="deployable_model_3(1)" />

  LandingLens creates a deployable model and opens to the **Deployable Models** table on the **Deploy** page.

  <Info>Models from [Visual Prompting](./visual-prompting) and the [Classic Flow](./classic-flow) use a separate deployment workflow and don’t display in the Deployable Models table.</Info>
</Update>

<Update label="November 21, 2023">
  ## November 21, 2023

  In this newest release of LandingLens, we’ve added more ways to manage your datasets. Here are the highlights:

  * You can now save “snapshots” of all or some images in a project, and train models based on those groups of images. You can have multiple snapshots in each project!
  * You can add tags (keywords) to images.
  * LandingLens automatically saves all models during model training.
  * You can now apply split, metadata, and tag information when uploading images to any project type.

  To learn more about these features, keep reading!

  ### Changes to Dataset Versioning: Introducing Dataset Snapshots

  In recent LandingLens releases, training a model and saving it created a “snapshot” of all the data in that model, including the images, labels, and predictions. You could create a new project from a dataset and even revert back to one. However, datasets were only saved for models, and you couldn’t train based on those datasets.

  In this release, we’ve made the dataset versions more flexible, and we’re now calling them “dataset snapshots”, or “snapshots” just for short. Here are some of the things you can now do:

  * Create a snapshot at any time! You no longer have to train a model to create a snapshot.
  * Create a snapshot based on all the images in your project OR on the specific ones you’ve selected.
  * Train a model using only the snapshot.
  * Download the Pascal VOC files and class map for a snapshot. This gives you the ability to re-upload the labeled images to LandingLens in the future, if needed.

  Plus, you still have the ability to create new projects from snapshots, revert your project to a snapshot, and download a CSV with snapshot information.

  For detailed information, go to [Dataset Snapshots](./dataset-snapshots) and watch the following tutorial:

  <iframe title="YouTube video player" />

  ### Tag Images

  You can now add tags (keywords) to images in your dataset! Using tags helps you organize and filter the images in your dataset.

  For example, let's say that you have images from Camera A and Camera B. You can create a tag for each camera and apply the tags to the corresponding images. Then, after you train a model, you can filter by all Camera A images, and see how the model performed on those. You can then do the same for Camera B images.

  Tags are project-specific; creating a tag in one project doesn't add it to other projects. You can apply multiple tags to each image.

  For detailed information, go to [Tags](./tags) and watch the following tutorial:

  <iframe title="YouTube video player" />

  ### All Trained Models Are Now Automatically Saved

  When you train a model, LandingLens now automatically saves and names it. This ensures that you can access all versions of your data in the [snapshots dashboard](./dataset-snapshots) and prevents models from being accidentally overwritten.

  The default model naming convention is **Model-mm-dd-yyyy\_n**, where **n** is the number of models in the project trained that day. For example, let’s say you train six models in a project on December 10, 2023. The default name of the sixth model will be **Model-12-10-2023\_6**. You can [rename a model](./model-settings) at any time.

  <img alt="model_name_11_2023" />

  ### Consistent Upload Experience

  You can now apply split, metadata, and tag information when uploading images to any project type. Previously, you could only apply splits when uploading information to Segmentation projects. The updated upload page provides a more consistent experience and allows you to apply important information at upload.

  <img alt="uploadExperience_11_2023" />
</Update>

<Update label="October 30, 2023">
  ## October 30, 2023

  We've had many requests for this specific feature, and the long wait is finally over—you can now create a new project by copying an existing dataset version! This creates a new project with the selected dataset.

  When you copy a dataset, you can even include the existing labels and metadata.

  <img alt="dataset_clone_2" />

  For more information, check out the tutorial video below.

  <iframe title="YouTube video player" />
</Update>

<Update label="October 10, 2023">
  ## October 10, 2023

  This newest version of LandingLens gives you more flexibility across the board. In this release, we've added:

  * A new way to upload images to your projects—via your smart phone!
  * Support for an additional file type—MPO
  * A new member type—Owner
  * The ability to change a user’s member type
  * More transparency for the credits used in deleted projects

  For detailed info on each of these updates, keep reading!

  ### Upload Images from Your Phone Directly into a LandingLens Project

  You can now upload images from your phone directly into a project in LandingLens. To do this, click the **Upload** icon, then click **Upload from Your Phone**.

  Generate and scan the QR code, and then take photos or select existing ones. All images are then uploaded into your project. To learn more, go to [Upload Images from Your Phone](./upload-images-phone).

  <img alt="qr_upload_3" />

  ### LandingLens Now Supports MPO Files

  You can now upload **MPO** (Multi-Picture Object) files to LandingLens. An MPO file contains two JPG files that create a stereoscopic image when overlaid. When you upload an MPO file to LandingLens, LandingLens selects one of the two JPG files.

  For more information about supported file types, go to [Upload Images](./upload-images).

  ### Owners and Changing Role Types

  Before this new version, LandingLens offered two member types: **Collaborators** and **Admins**. Once you assigned a member type to a user, you couldn't change their role.

  This new version of LandingLens now offers a new role called **Owner**. Owners have all the permissions as Admins, plus the ability to change a member's role! For example, if Anna was originally added as a Collaborator, but now she needs access to the API Key page, an Owner can "upgrade" Anna to be an Admin.

  An organization can have up to three Owners. To learn more information, go to [Member Roles](./members).

  <img alt="members_make_admin" />

  ### Track Credits for Deleted Projects

  If you delete a project, the credits used on that project are now easier to track on the **Usage** dashboard.

  Previously, if you deleted a project, the **Top Projects: By Credits** and **Top Project: By Images** sections would show “(private project)” instead of the project name. Now, if you delete a project, the project name displays, making it easier to understand how credits were used.

  The **Usage Log** continues to show “-” instead of the names of deleted projects, because LandingLens pulls this data from a different place.

  For example, let’s say you deleted a project called “Quality Control”. The following screenshot shows how the **Usage** page would look after deleting the project.

  <img alt="delete_project_staging_after_callouts" />

  The following table summarizes the changes:

  | Section                  | Before            | After        |
  | ------------------------ | ----------------- | ------------ |
  | Top Projects: By Credits | (private project) | Project Name |
  | Top Projects: By Images  | (private project) | Project Name |
  | Usage Log                | -                 | -            |

  ### Bug Fixes

  For users on the [Classic Flow](./classic-flow) version of LandingLens: The **Job** hyperlinks on the **Models** tab now work correctly.
</Update>

<Update label="September 19, 2023">
  ## September 19, 2023

  Welcome to the latest release of LandingLens! This update streamlines your project management experience.

  Now, when navigating the Projects page, you can effortlessly filter your search results by project type, providing you with even more refined control over your workflow. You can also now rename, delete, and invite users to projects directly from the Projects page.

  Additionally, the ability to delete classes can now be enabled upon request for the [Classic Flow](./classic-flow) version of LandingLens.

  For more information, read the full release notes below.

  ### New Features and Improvements

  #### Filter by Project Type

  When searching for a specific project on the Projects page, you can now filter by project type. To do this, enter your search term in the search bar and click the project type you want to search for.

  For more information on searching for projects, go to [Search for Projects](./view-projects).

  <img alt="Projects_search_type" />

  #### More Ways to Manage Projects

  You can now perform these actions directly from a project card on the Projects page:

  * Rename the project
  * Invite users to the project (only applicable to private projects)
  * Delete the project

  To access these options, click the **Actions** icon on the project card. For more information on managing projects from the Projects page, go to [Search for Projects](./view-projects).

  <img alt="project_card_actions_releasenotes" />

  #### Classic Flow Supports Ability to Delete Classes

  If you are using the [Classic Flow](./classic-flow) version of LandingLens, the ability to delete classes can now be enabled. To request this feature, contact your  representative.

  For more information about deleting classes, go to [Delete Classes](./delete-classes).

  ### Bug Fixes

  * You no longer need to refresh the page to update how long ago a model was trained. Now, the time is updated automatically.
  * If you delete a label or “discard” the name of a class before you create it in a Visual Prompting project, those changes are now saved. Previously, the label or class would still appear.
  * We improved the transition from training a Visual Prompting model to seeing the results. Now, the predictions and model information load faster.
</Update>

<Update label="August 10, 2023">
  ## August 10, 2023

  ### More Details Now Display on Project Cards

  Project cards now display the total number of images in your dataset and trained models. You can hover over the icons to view more information, like the number of labeled images.### New Login Page Design

  We've introduced a fresh look for the LandingLens login page.### Revamped the Model Sidebar

  When you don't have any trained models, the Model sidebar displays a tooltip to help you effortlessly progress through the platform.### The Polygon Shortcut Changed from "P" to "W"

  LandingLens is equipped with several keyboard shortcuts. For Segmentation projects, the shortcut for the Polygon tool changed from "P" to "W".

  ### Bug Fixes

  * Changed the file naming convention for downloaded CSV files of dataset snapshots. These files are now be named after the model and the date the file was downloaded.
  * A few "behind-the-scenes" bugs were fixed.
</Update>

<Update label="July 28, 2023">
  ## July 28, 2023

  This newest version of LandingLens includes features to make it easier to manage your dataset and deploy your model!

  ### Dataset Snapshots: More Control and Visibility into Your Dataset

  With this release, we’re introducing the concept of dataset “snapshots”. Now, whenever you train a model, LandingLens saves your dataset—and the model’s predictions—as a “snapshot” that you can continue to access in your Project. With dataset snapshots, you can:

  * [Revert to an earlier dataset](./landinglens-release-notes#revert-to-an-earlier-dataset)
  * [Download a CSV of information about the dataset](./landinglens-release-notes#download-a-csv-of-dataset-information)
  * [See when the dataset information is gathered during the training process](./landinglens-release-notes#changes-to-the-model-training-process)

  We’ve also [redesigned](./landinglens-release-notes#changes-to-the-model-information-popup-window) the model pop-up window to make it easier to navigate all the model information and reports.

  #### Revert to an Earlier Dataset

  You can now revert your Project to use an earlier dataset. For example, let's say that you trained a model, and later added more images and labels. After training the model a second time, you see that the first model performed better, so you want to go back to that dataset. You can do this by reverting the dataset.

  <img alt="model_revert_1" />

  #### Download a CSV of Dataset Information

  In Object Detection and Classification projects, you can now download a CSV of information about the dataset. The CSV includes several columns of data, including Project Name, Image Name, Split.

  <img alt="model_csv_2" />

  #### Changes to the Model Training Process

  When you click **Train**, the first step in the model training process is now to gather and save the images and data currently in your Project. This information is part of the “dataset snapshot” that you can later revert to.

  This step displays as **Taking a snapshot of your data** in the Model panel.

  <img alt="train_1" />

  For more information about the model training process, go to [Train Models](./train-models).

  #### Changes to the Model Information Pop-Up Window

  We’ve redesigned the Model pop-up window to make it easier to navigate. The pop-up is now organized into multiple tabs.

  <img alt="ModelSettings_tabs" />

  ### Mobile Inference Support in Segmentation and Visual Prompting

  You can now use Mobile Inference on Segmentation and Visual Prompting Projects. Previously, it was only available for Object Detection and Classification Projects.

  ### Streamlined Deployment Workflow from Build Page

  We’ve streamlined the workflow for deploying a model from the Build page. When you click Deploy, you can now simply enter the model name and select your endpoint.

  <img alt="build_deploy_1" />

  <img alt="build_deploy_2" />

  ### Downloadable Pascal VOC Files Now Available for Classification Projects

  Before, downloadable Pascal VOC files were only available for Object Detection and Segmentation projects. Now, we've made this feature available for Classification projects.

  ### Bug Fixes

  * Selected images moved to a different split will no longer remain selected.
  * You no longer need to refresh the browser to save a model.
  * Users in classic flow can resume deploying from the Models page.
  * Fixed multiple issues related to deleting classes.
  * Fixed multiple issues related to creating an endpoint with a name that already exists in that project.
  * Changed the copy of the "Defect" filter to "Class".
  * Fixed the login process for SSO.
</Update>

<Update label="July 5, 2023">
  ## July 5, 2023

  We are thrilled to announce , a new tool that helps you label objects in Segmentation Projects faster and with more accuracy.

  When  is enabled, simply hover over the object you want to detect, click, and press enter.  automatically detects the shapes you want to select and applies your selected Class!

  To learn more, check out [Label with Smart Labeling](./segmentation#label-with-smart-labeling).

  <img alt="smart_lion" />

  ### New API Key System

  Up until this release, LandingLens required both an API Key and API Secret to be used to run inference. After evaluating our user experience and current industry standards, we decided to eliminate the use of the API Secret. As of this release, LandingLens generates and requires only an API Key!

  All existing API Key and API Secret pairs will continue to be valid, and all applications using those credentials will continue to work.

  You can create multiple API Keys. This gives you more flexibility and control over who can run inference with your deployed Models. Additionally, you can revoke and delete API Keys.

  For more details, check out [API Keys](./api-key).

  <img alt="api_key_landing(1)" />

  ### New Way to View the API Command for Deployment

  We now offer a new way to get the API call on the Deploy page. Now you can click the **Actions** icon and select **View API Command**.

  <img alt="ViewAPICommand(1)" />

  ### Bug Fixes

  * If you delete a Class, you can now create a new Class with the same name as the deleted Class.
  * When using the QR code for [Mobile Inference](./mobile-inference), some users got this error: “Missing user record with apikey or user id: -1”. The issue that caused this error has been fixed.
  * If a Class was deleted in a Classification Project, the model metrics were also deleted for that Project. The issue that caused this error has been fixed.
</Update>

<Update label="June 22, 2023">
  ## June 22, 2023

  ### Improvements

  We've added these improvements to help you manage your credits and pricing plan:

  * If you reach your Project maximum, LandingLens now alerts you with a new tile. The Project maximum applies to the current number of Projects, so you can delete an existing Project to create another one. Or, if you want an unlimited number of Projects, upgrade to a Visionary or Enterprise [plan](https://landing.ai/pricing/).
    <img alt="project_upgrade" />
  * If training a Model or running inference will put you above your credit maximum, LandingLens now alerts you with a pop-up that guides you through the next steps.
    <img alt="increase_credit_limit" />

  ### Bug Fixes

  If you have a long Model name, it’s now shortened when it displays in the user interface. Hover over the name to see the full name. Previously, long Model names would attempt to wrap to a second line, but the top of the text would get cut off.

  <img alt="model_name_truncate" />
</Update>

<Update label="June 14, 2023">
  ## June 14, 2023

  We're thrilled to unveil the latest release of LandingLens! This version empowers you with more ways to run inference on the computer vision Models you create in LandingLens. You can now use your smartphone to capture images and immediately see your Model’s predictions. Additionally, all users can now download a 14 day free trial of LandingEdge!

  We’ve also streamlined the process to develop Models by expanding our Workflow Assistant to new Project Types and making it easier to end the Model training process.

  Learn more about these updates below!

  ### Use Your Model on a Smartphone with Mobile Inference

  &#x20;is excited to share that we’ve developed a new feature—! This feature empowers you with an additional way to use your LandingLens Model in the real-world. For detailed information, go to [Mobile Inference](./mobile-inference).

  After you develop your Model and deploy it to an endpoint, you can then generate a QR code by clicking the **QR** code icon.

  <img alt="deploy_olderpage_1" />

  Scanning the QR code with your phone opens the LandingLens app in your browser.

  <img alt="mobile_app_scan_QRcode(1)" />

  From there, you can take a photo or select an image from your phone. The app sends the photo to your deployed Model, and your Model runs inference on it. The Model’s predictions then display immediately on your phone!

  <img alt="choose_photo" />

  The images and predictions are also saved back to LandingLens, so that you can review all results in a centralized location. You can also share the QR code with your colleagues, so that you can all collaborate on running inference.

  <img alt="mobile_app_historic_data(1)" />

  ### Clearly-Defined Deployment Options

  We’ve added more visual guides to the Deploy page to help you choose the right deployment method for your use case.

  For example, when you first click Deploy, you’ll see two options for how to use your model.

  * **Cloud Deployment**: Click to create an endpoint, which is a virtual location that hosts your Model. You can then send images to the Model via API requests, or use a new feature called Mobile Inference to run your Model on your smartphone (more info on that [below](./landinglens-release-notes#use-your-model-on-a-smartphone-with-mobile-inference)).
  * **Edge Deployment**: Click to deploy your Model via LandingEdge, the  application that connects to your edge devices.<img alt="CloudDeploynent_CreateEndpoint" />

  ### Download a Free Trial of LandingEdge

  You can now download a free trial of LandingEdge directly from LandingLens!

  If you haven't deploy a Model yet, open a Project to the Deploy page and click **Download LandingEdge**. Then follow the on-screen prompts to complete the download. For detailed information, go to [LandingEdge Overview](./landingedge/landingedge-overview).

  <img alt="Download_LE_new" />

  If you’ve already deployed a Model via Cloud Deployment, click **LandingEdge**.

  ### Workflow Assistant

  We added the **Workflow Assistant** to Segmentation and Classification Projects. The Workflow Assistant includes a progress bar at the top of your Project that guides you through all the steps of developing a computer vision Model, from uploading images to your dataset to using your Model to make predictions.

  <img alt="workflow_asst_clsf" />

  When you hover over the Workflow Assistant, it nudges you in the right direction by “shaking” the buttons you need to click to move to the next step. For example, after you’ve labeled at least 10 images, the Train button shakes, letting you know that you have enough data to create your first Model.

  <img alt="workflow_asst_train" />

  ### End Training Early

  We’ve provided you with more on-screen guidance about what happens if you end the Model training process before it’s completed.

  Model training can only be ended at **Step 3: Training & Learning**, which is when the model training process actually begins. The **Stop Training** button is now **End Training Now**.

  <img alt="EndTrainNow_crop" />

  If you end Model training early, LandingLens completes its current round (epoch) of training and evaluates the images in your dataset with the Model it had generated up to that point. The Model may not be as accurate as it would be if training had completed.  For detailed information, go to [Train Models](./train-models).

  ### Large Image Support

  When using Custom Training in LandingLens Enterprise, you can now resize images in Object Detection and Segmentation Projects to be up to 36MP. For detailed information, go to [Custom Training](./custom-training).

  ### Bug Fixes

  We fixed a bug in [Agreement-Based Labeling](./agreement-based-labeling) that allowed you to filter by users who weren’t assigned any tasks. Now, you can only filter by users who have been assigned tasks.
</Update>

<Update label="June 5, 2023">
  ## June 5, 2023

  ### What’s New

  To make it easier to understand some of the features, we updated some of the user interface text throughout LandingLens.

  ### Bug Fixes

  * We fixed an issue that caused [Labeling Tasks](./agreement-based-labeling) to show that a negative number of images needed review. Now, the number of images under review is calculated correctly.
  * We fixed a bug that caused the Class colors in Predictions to be different from the actual colors assigned to those Classes.
</Update>

<Update label="May 24, 2023">
  ## May 24, 2023

  ### What's New

  * When you delete a Class, LandingLens now shows you a pop-up that lists the impacts of deleting a Class. This empowers you to make an informed decision and helps prevent accidentally deleting Classes. For more information, go to [Delete Classes](./delete-classes).
    <img alt="DeleteClass_confirm" />
  * You can now delete a Class when labeling images. For more information, go to [Delete Classes](./delete-classes#delete-classes-when-labeling).
    <img alt="DeleteClass_label_2" />
  * We improved the experience with labeling images in Classification Projects. Previously, if you selected a label for an image on the Build tab, LandingLens would have to refresh the page to save the change. Now when you select a label, LandingLens saves the change without refreshing the page.
  * We made it easier to upload sample images in our Example projects. Previously, you had to click the sample images to upload them. Now you can also drag and drop them.
    <img alt="example_dragndrop" />
  * We updated the process for creating a new organization in LandingLens. You’ll now be prompted to name your organization and select your use case: Work, Academic, or Personal.
    <img alt="new_org_3" />

  ### Bug Fixes

  * LandingLens now prevents you from creating two Classes with the same name. Previously, it was possible to reuse the same name but with different capitalization (for example, “Scratch” and “scratch”).
  * When you hover over the **Train** button, a tooltip shows you how many credits the training process will cost. It costs 1 credit to train each image. LandingLens trains a model based on all images in your Project, not just the images that are filtered to display. Previously, the tooltip calculated the cost based on only the filtered images. How, the tooltip now correctly calculates the cost to include all images.For example, the Project in the image below has 13 images. A filter is applied which causes only 3 images to display. However, the tooltip correctly states that training the Model cost 13 credits.
    <img alt="training_credits" />
</Update>

<Update label="May 16, 2023">
  ## May 16, 2023

  The ability to delete Classes has been re-enabled. It was temporary disabled due to some reported issues. The  team has resolved these issues.

  When you delete a Class, all labels on images for that Class are also removed. If you delete a Class after training your Model, train it again. For more information about how to delete Classes, go to [Delete Classes](./delete-classes).

  <img alt="DeleteClass_2" />

  <Info>Deleting Classes is not supported in [Classic Flow](./classic-flow).</Info>
</Update>

<Update label="May 15, 2023">
  ## May 15, 2023

  The Check Label Quality feature has been re-enabled. It was temporary disabled due to some reported issues. The  team has resolved these issues.
</Update>

<Update label="May 4, 2023">
  ## May 4, 2023

  ### What's New

  * We added a keyboard shortcut for the Eraser tool in [Visual Prompting](./visual-prompting). You can now press **E** to select the Eraser tool.
    <img alt="eraser_shortcut" />
  * Members that are Collaborators can now access other Organizations that they are members of in LandingLens. Users can only access Organizations that they are Admins or Collaborators of. For more information about accessing Organizations in LandingLens, go to [Switch Organizations](./organizations#switch-organizations).

  ### Bug Fixes

  * The **Load Sample Data** pop-up window was briefly too narrow, which caused the text to overlap. This pop-up window has now been resized to fit all the text correctly.
    <img alt="LoadSampleData" />
  * If you add labels to an image in [Visual Processing](./visual-prompting), your changes are now saved if you select another image before clicking **Run**.
  * The keyboard shortcuts for changing the **Brush size** and **Eraser** **size** in Visual Processing now work correctly.

  ### Other Updates

  The Check Label Quality feature is temporary disabled due to some reported issues with this tool. We will notify you in the Release Notes once these issues have been fixed and the feature re-enabled.
</Update>

<Update label="April 25, 2023">
  ## April 25, 2023

  &#x20;is thrilled to announce the Beta release of an innovative, new capability in LandingLens: .

  &#x20;is a paradigm shift in the field of computer vision. You label only a few small areas of an object in a few images, and the Model almost immediately detects the whole object in all of your images.

  ### &#x20;Workflow

  &#x20;has a highly iterative—and yet fast—workflow. After you upload images to your Project, start labeling one. Use the Brush “paint” a small area of the first object you want to detect. When prompted, enter a name for the object. This is your first Class.

  <img alt="Pandas_class1" />

  Then, use the Brush to paint a small area of another object you want to detect. This is your second Class. If you only want to detect one object type, that’s okay—simply name your second Class “Background” or something similar. You can have multiple Classes, but create at least two to get started.

  <img alt="Pandas_class2" />

  Then click **Run**! The Model shows you its Predictions in just a moment, in both the image you labeled and the other images in your dataset. In most cases, the Predictions won’t be perfect at first. Not only is that okay, that’s expected. You can now fine-tune your labels.

  <img alt="Panda_results" />

  ### Get Started with&#x20;

  You can create a  Model in seconds and deploy in minutes. You don’t even need a background in computer vision, machine learning, or any type of AI!

  To learn more details, check out our full support article on [Visual Prompting](./visual-prompting). Start using  today by signing up for a [LandingLens free trial](https://app.landing.ai/signup)!

  <Info>Visual Prompting is in Beta. It might not function as well as our other production-ready features.</Info>
</Update>

<Update label="April 21, 2023">
  ## April 21, 2023

  Today’s release of LandingLens includes a few behind-the-scenes bug fixes.

  We also included a workflow improvement that will keep your Projects running smoothly. In the past, it was possible to create a Project, create a Class, and then change the Project Type (for example, from Object Detection to Segmentation). That would confuse the backend, because the label infrastructure for each Project Type is very different.

  The newest version of LandingLens prevents you from changing the Project Type after creating Classes. If you want to use a different Project Type, simply delete the Project and create a new one.

  <img alt="ChangeProjectType_before" />

  <img alt="ChangeProjectType_after" />
</Update>

<Update label="April 5, 2023">
  ## April 5, 2023

  [Labeling Tasks](./agreement-based-labeling) in Segmentation Projects are now assigned to users in batches of five images. For example, if you create a Labeling Task with 10 images and assign it to a user, that user will get two batches of five images each.

  <img alt="batches" />

  <img alt="LabelTask_Seg" />
</Update>

<Update label="March 30, 2023">
  ## March 30, 2023

  * Previously, the “internal” names for Models displayed in certain areas of the user interface. This included the Historical Data section in LandingLens, and the Model drop-down menu in LandingEdge. Now, the Model name and your selected Confidence Threshold display, so that you can easily choose which Model you want to use. The following images show how the Model names look before and after this update.
    <img alt="ModelName_before" />
    <img alt="ModelName_after" />
  * We’ve made it easier to upload images to new Projects! Now you can click anywhere below the Project Types to open the Upload pop-up window. Previously, only clicking the Drop to Upload icon would open this pop-up.
    <img alt="Upload_mar_4_2023" />
  * We’ve changed how Model training runs in the LandingLens backend. This change isn’t visible in the user interface, and doesn’t impact the speed or accuracy of your Model.
</Update>

<Update label="March 22, 2023">
  ## March 22, 2023

  We updated a few things in the background to optimize the LandingLens experience. We are continuing to work on adding new features, and we can't wait to share them with you soon!

  Additionally, we updated a few articles:

  * [Cloud Deployment](./cloud-deployment)
  * [LandingEdge Specifications Sheet](./landingedge/landingedge-specifications-sheet)
  * [How many images do I need to upload for model training?](./curate-high-quality-datasets)
</Update>

<Update label="March 16, 2023">
  ## March 16, 2023

  ### What's New

  * You can now include Chinese, Japanese, and Korean characters in your Project name.
    <img alt="ProjectNameJapanese" />
  * If you rescale images for custom Model training, LandingLens now provides text to ensure that your image fits within the minimum and maximum area constraints.
    <img alt="MaxArea" />

  ### Bug Fixes

  * Previously, if you selected a Model on the Deploy page and then opened the Build page, that same Model would be selected. Now, selecting a Model on the Deploy page doesn’t change the Model shown elsewhere.
  * Previously, if you added Data Augmentation to custom Model training and then deleted those settings, the Data Augmentation would still be applied. This issue has been fixed. If Data Augmentation is deleted, it won’t impact training.
  * We fixed a bug that occurred when trying to upload images from a WebCam to some Classification Projects.
</Update>

<Update label="March 10, 2023">
  ## March 10, 2023

  We discovered that naming a Class “Ok” could cause issues when training a Model in Object Detection and Segmentation Projects. To ensure that your Model is trained correctly, LandingLens no longer accepts “Ok” (or any variation of its capitalization) as a Class name for these Project Types. You can continue to use “Ok” as a Class in Classification Projects.
</Update>

<Update label="February 22, 2023">
  ## February 22, 2023

  ### Announcements

  * We now offer multiple pricing plans for LandingLens! There is something for teams of all sizes. Whether you’re an AI hobbyist or a manufacturer that needs an AI solution to provide QA on your production line, we have a plan for you. Check out these new plans on our [Pricing](https://landing.ai/pricing/) page.
  * We’ve launched [LandingPad](https://community.landing.ai/), a community for  users. Looking for tips or insights about using LandingLens? Interested in learning more about specific use cases? Then check out [LandingPad](https://community.landing.ai/)!

  ### What’s New

  * You can now upgrade your pricing plan directly in LandingLens! Not sure what you need or want to discuss your use case? You can still contact our [Sales](https://landing.ai/contact-sales/) team at any time.To change your plan, click the **User Menu** in the top right corner, and select **Plan and Billing**. Then click **Change Plan**.
    <img alt="ChangePlan(1)" />
  * You can now track credit usage metrics in the new **Usage** dashboard. To view the dashboard, click the **User Menu** in the top right corner, and select **Usage**.
    <img alt="Usage" />
  * You can now upload sample images to a Project directly from LandingLens. To do this, create a new Project and click **Load Sample Data**.
    <img alt="LoadSampleData_1(2)" />

  ### Bug Fixes

  * You can now see the total number of filtered images.
  * We fixed a bug that hid images when switching from Instance View to Image View.
</Update>

<Update label="February 12, 2023">
  ## February 12, 2023

  **We've Got a New Look**

  Today we released several new features and changes to the look and feel of LandingLens.

  * **Login page**: You may have noticed we spruced up the login page with a new design.
    <img alt="login" />
  * **Home page**: The new home page will be the new core page, where we will provide you with organization information, important updates, and access to your most recent projects.
    <img alt="home" />
  * **Pre-trained examples**: We have included some examples of how LandingLens can be used. Go to **Examples**, and check out some of our pre-trained models!
    <img alt="Examples" />

  **Deployment Page**

  We've got a new look and experience for the **Deploy** page. We have improved the flow and experience of the Deploy page by adding easier navigation across your various devices (now called "endpoints") and access to the historical data associated with each endpoint. For more information, go to [Cloud Deployment](./cloud-deployment).

  <img alt="deploy" />

  Here are some highlights:

  * **Endpoints** (previously known as Devices) can be found under **Cloud Deployment** in the navigation bar on the left. You can deploy each endpoint with a trained Model and fixed Confidence Threshold. You can update your Model and Confidence Threshold by selecting **Update Deployment**.
  * The **Predict** tool allows you to quickly drag and drop an image to run inference and test your Model.
  * Images sent to the endpoint through the API integration will show up under **Historical Data**, just like before.
  * You can find your **API Key** and **API Secret** conveniently located in the navigation bar on the left.
</Update>

<Update label="January 20, 2023">
  ## January 20, 2023

  ### What's New

  We've upgraded how [default training](./train-models) works for Classification models to improve the performance of these models.

  ### Bug Fixes

  Previously, when a model training job failed, an error would display, and users could not retrain the model. We fixed this so users can retrain models.
</Update>

<Update label="January 17, 2023">
  ## January 17, 2023

  ### Announcement

  The Support Center URL changed from [https://support-landingai.document360.io/](https://support-landingai.document360.io/) to [https://support.landing.ai/](https://support.landing.ai/).

  ### What's New

  * LandingLens now displays a workflow assistant to guide you through creating your first Object Detection Project. Hover over the workflow assistant to read more information about your current step.
    <img alt="Workflow Assistant" />
  * LandingLens introduces a new feature called "Predict". Predict allows you to quickly upload new images to your Model so that the Model can make predictions on those images. Predict streamlines the Run Live feature so you can deploy Models faster.
    <Info>"Predict" is currently only available for trained Object Detection Models.</Info>

  ### Bug Fixes

  Fixed: Users can resume exporting training datasets.
</Update>


# LandingLens vs. LandingLens on Snowflake
Source: https://landinglens.docs.landing.ai/landinglens-vs-landinglens-on-snowflake



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✖</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

For the most part, the experience using  is the same as using [LandingLens directly from LandingAI](https://app.landing.ai/signup). In both, you will upload and label images, and then train and deploy computer vision models.

If you're using , you get the exclusive benefits of data governance, Snowflake Copilot, and more.

If you've used LandingLens from LandingAI before, you might notice that some features are different or absent. Some features and concepts are not relevant when using LandingLens in Snowflake, because Snowflake inherently provides those concepts or handles them differently.

The following table lists concepts that aren't found in  because they are handled differently by Snowflake

| Concept or Feature                              | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| ----------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| LandingLens credits, pricing plans, and billing | Credits, pricing, and billing are managed in Snowflake.                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| LandingLens API keys                            | Authentication is managed in Snowflake.                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| LandingLens members and roles                   | Access to LandingLens is managed using the secure and granular access controls in Snowflake.                                                                                                                                                                                                                                                                                                                                                                                                        |
| Examples page and Load Sample Data              |  users can access sample datasets by getting these apps in the Snowflake Marketplace:<ul><li>[Sample Dataset for LandingLens: Manufacturing Metal Casting](https://app.snowflake.com/marketplace/listing/GZTYZ12K65C6/landingai-sample-dataset-for-landinglens-manufacturing-metal-casting) </li><li>[Sample Dataset for LandingLens: LifeSciences Pneumonia](https://app.snowflake.com/marketplace/listing/GZTYZ12K65CA/landingai-sample-dataset-for-landinglens-lifesciences-pneumonia)</li></ul> |

<Info>Other differences between LandingLens and  are marked throughout the documentation.</Info>


# LandingLens Workflow
Source: https://landinglens.docs.landing.ai/landinglens-workflow



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

LandingLens is a cloud-based platform that allows you to develop and deploy computer vision models, all without needing a background in deep learning or artificial intelligence.

After you [sign up](https://app.landing.ai/signup) for LandingLens, follow this workflow to create and deploy your computer vision model:

1. [Create a project](./create-projects).
2. [Upload images to that project](./upload-images).
3. [Create classes](./create-classes).
4. [Label your images](./labeling).
5. [Train your model](./train-models).
6. [Review the predictions](./view-predictions). If needed, improve your dataset, retrain your model, and repeat until you're happy with your model's performance.
7. [Deploy your model](./deployment-options).

## LandingLens Video Walk-Through

Learn how to use LandingLens directly from Andrew Ng, the Founder of ! In the following video, Andrew Ng walks you through the process of creating a computer vision model in LandingLens. He explains how to upload images, train a model, and test it on new images it has never seen before!

<iframe title="YouTube video player" />

<Info>Want to see more videos about how to use LandingLens? Check out our [Video Tutorial Library](https://community.landing.ai/c/video-tutorial-library/)!</Info>


# Lense (Optics)
Source: https://landinglens.docs.landing.ai/lenses



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

The purpose of a lens is to collect the light scattered by an object and recreate an image on a light-sensitive image sensor.

We’ve defined the key factors that should be considered when choosing optics in the following table.

| Lens Factor                 | Definition                                                                                  |
| --------------------------- | ------------------------------------------------------------------------------------------- |
| field of view (FOV)<br />   | The total area that can be viewed by the lens and imaged onto the camera sensor.<br />      |
| working distance (WD)<br /> | The distance between the object and lens where the image is at its sharpest focus.<br />    |
| depth of field (DoF)<br />  | The maximum range where the object appears to be in focus.<br />                            |
| magnification<br />         | The ratio between the sensor size and the FOV.<br />                                        |
| optical resolution<br />    | The minimum distance between two points that can be distinguished as separate points.<br /> |

## Keep the "Big Picture" in Mind

Choosing the right lens is just one part of setting up your image capture system. Make sure you also select the right [camera](./cameras) and [lighting](./lighting).

The guiding principle in developing your camera, lens, and lighting system is that it should lead to reliable and repeatable results. Good data in leads to good data out.


# Lighting
Source: https://landinglens.docs.landing.ai/lighting



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

Lighting is one of the most critical components of a vision solution. The selection of the appropriate lighting component for an application is critical to ensure the vision system performs its tasks consistently and reliably.

The role of application-specific lighting is to ensure that all features of interest are isolated and visible contrast is created between the object and background. In most cases, software cannot “fix” or create visible contrast if a feature is not correctly illuminated.

## Keep the "Big Picture" in Mind

Choosing the right lighting is just one part of setting up your image capture system. Make sure you also select the right [camera](./cameras) and [lens](./lenses).

The guiding principle in developing your camera, lens, and lighting system is that it should lead to reliable and repeatable results. Good data in leads to good data out.

## Goals of Lighting Systems

The goal of a lighting system in a computer vision application is to:

* Maximize the contrast of the features to be inspected or measured
* Minimize the contrast of the features of no interest
* Remove unwanted variations caused by ambient light and unwanted differences that are not relevant to the inspection task.

It may be necessary to perform feasibility studies with different lighting options to isolate features of interest.

## Lighting Best Practices

Our partner, Smart Vision Lights, provides the [“A-T-E-S-T” method](https://smartvisionlights.com/wp-content/uploads/ATEST-scaled.jpg) to help users identify the effects of different lighting techniques on part features:

<img alt="ATEST-scaled" />

## Key Lighting Parameters

To choose the most suitable light for a project, consider the following parameters:

* Lighting geometry, which is the arrangement and interaction between light sources and objects.
* Light source type
* Wavelength
* Surface characteristics of the material to be inspected, such as color and reflectivity
* Object shape
* Item speed
* Mechanical constraints
* Cost

## LED Light Pulsing and Strobing

LED lights can be used continuously to illuminate an object. Alternatively, LED’s can be pulsed (on or off) turning them on when necessary.

An LED is in **pulsed** mode if the LED driving current or voltage is set to the nominal value declared by the LED manufacturer for a specific amount of time and reset to zero. Pulsing offers the following advantages:

* Preserves the lifespan of the light
* Reduces power dissipation
* Reduces heat generation

An LED is in **strobed** mode if the LED is driven at higher intensity than the nominal value (over driven) producing more light for a nominal amount of time. Strobing offers the following advantages:

* Ideal when the application requires an increased amount of light to “freeze” the motion of the object
* Eliminates the effects of ambient light
* Preserves the lifespan of the light

## Can I use ambient light?

It might be tempting to use ambient light—in other words, whatever light is available—to get images. However, the specific type of lighting, or changes in lighting, can have a big impact on objects or defects showing up consistently in photos.

For example, if you want to detect fine cracks on a metal surface, then the lighting in your production floor might create shadows or reflections on metal objects, hindering the camera's ability to take an accurate image.

We generally recommend implementing a lighting solution that is controlled and ensures consistent results.


# LLENS_PUBLIC Application Role
Source: https://landinglens.docs.landing.ai/llens-public-application-role



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✖</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

Many functions for managing  require the LLENS\_PUBLIC application role, including the ability to:

* [Run inference with SQL commands](./run-inference-with-sql-commands)
* [Suspend and resume the LandingLens app](./credit-management)

Application roles can't be granted directly to users, so you must grant LLENS\_PUBLIC to an account role (or to another application role that is then granted to an account role).

For example, the following commands create an account role called LANDINGLENS\_EXTERNAL\_ACCESS, grant that role to a user, and then grant the application role to the account role. Replace `<user_name>` with the name of the Snowflake user, and `APP_NAME` with the name of your LandingLens instance. To locate the name, go to [Name of LandingLens Instance](./app-name).

```bash theme={null}
CREATE ROLE LANDINGLENS_EXTERNAL_ACCESS;
GRANT ROLE LANDINGLENS_EXTERNAL_ACCESS TO USER <user_name>;
GRANT APPLICATION ROLE APP_NAME.LLENS_PUBLIC TO ROLE LANDINGLENS_EXTERNAL_ACCESS;
```

<Info>Only users with certain access can grant application roles. To see the requirements, refer to the [Snowflake documentation](https://docs.snowflake.com/en/sql-reference/sql/grant-application-role).</Info>


# Load Images from Snowflake into LandingLens
Source: https://landinglens.docs.landing.ai/load-images-from-snowflake



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✖</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

You can [use several methods](./upload-images) to upload images into a LandingLens project. When using , you can load images from a Snowflake stage into a LandingLens project using **Sync Snowflake Data**.

If you're in a Classification project, you can use this tool to [classify images at upload](./load-images-from-snowflake#classify-images-when-loading-from-a-snowflake-stage) (in other words, upload labeled images).

<iframe title="YouTube video player" />

## Sync Snowflake Data Overview

When you use the **Sync Snowflake Data** workflow, you select a stage that you want to load images from. Images with [supported file types](./upload-images) in the selected Snowflake stage are loaded into the LandingLens project. If the stage has directories, images in those directories are also loaded into LandingLens.

The **Sync Snowflake Data** workflow can load up to 10,000 images. Images can be loaded from both internal and external stages.

The **Sync Snowflake Data** tool only transfers data into LandingLens; it doesn't load data from LandingLens into Snowflake.

Additionally, **Sync Snowflake Data** only loads data each time it's run. For example, if you run **Sync Snowflake Data** and later add more images to the stage, those images aren't automatically loaded into LandingLens. However, manually running **Sync Snowflake Data** again will load the new images (it will ignore any images that have already been added to LandingLens).

## Prerequisite: Grant LandingLens Access to a Stage

Before you can load images from a stage into a LandingLens project, you must first run SQL commands to grant LandingLens access to that stage. To do this, go to [Grant LandingLens Access to Stages](./grant-landinglens-access-to-stages).

The SQL commands will require the database, schema, stage, and LandingLens application name. If you're not sure if LandingLens has access to the stage or what the application name is, start setting up the sync in LandingLens. If you don't have access to the stage, the app will [give an error](./load-images-from-snowflake#troubleshooting-the-sync-process) and generate the SQL commands you need to run.

## Load Images with Sync Snowflake Data

After [granting LandingLens access](./grant-landinglens-access-to-stages) to the stage with the images you want to load into LandingLens, you can load those images into a LandingLens project.

1. Open the project you want to load images to.
2. Click **Sync Snowflake Data**.
   <img alt="SyncSFData_1(1)" />
3. Enter the **database**, **schema**, and **stage** that have the images you want to load into LandingLens. The drop-downs automatically populate based on the locations that you created or have access to.
4. Click the directory path (`⌄ /`) in the **Folder** box. Use this field to navigate to and select a directory on the Snowflake stage.

* If you select the root directory (or don't select any directory), supported images from the stage and its directories will be loaded into LandingLens.
* If you want to load images from only a specific directory, select that directory.

5. Click **Sync**.
   <img alt="SyncSFData_2(1)" />
6. Images from the stage (or the selected directories) are loaded to the LandingLens project in batches. The page refreshes every 10 seconds to display new images until all are loaded.
   <img alt="SyncSFData_3" />

## Classify Images When Loading from a Snowflake Stage

If you're in a Classification project, you can automatically assign classes to images based on directory names when uploading data from a Snowflake stage. The approach is similar to how you classify images when uploading directories from your hard drive, as explained in [Classification](./classification).

You will need to first create directories and add images to them in the Snowflake stage. Then, you will select the directories when using the **Sync Snowflake Data** workflow.

<Info>The **Sync Snowflake Data** tool doesn't upload labels/classes for Object Detection and Segmentation projects.</Info>

### Set Up Directories in Snowflake

To classify images at upload, first organize the directories and images in a Snowflake stage:

1. Create a directory in a Snowflake stage. This will be your "root" directory.<br />
   **Example**: Create a directory named `data`.
2. Inside your root directory, create a sub-directory for each class you want to use. Name the sub-directories after the classes.<br />
   **Example**: Inside `data`, create directories named `normal` and `pneumonia`.
3. Add images to the sub-directories based on class name.<br />
   **Example**: If you want an image to be classified as `normal` in LandingLens, add it to the `normal`directory. The directory in your stage would look like this:
   <img alt="directory_prep" />

### Load and Classify Images from Directories

When you're ready to load images from the Snowflake stage, click **Sync Snowflake Data** and configure the settings:

1. Select the **Database**, **Schema**, and **Stage**.
2. Turn on **Classify images based on folder names**.
3. Click the directory path (`⌄ /`) in the **Folder** box.
4. Select the "root directory" that you created. For example, in the screenshot below, select **data**. Do NOT select the directory that actually contains the images.
   <img alt="SyncSF_classify_pneumonia_1" />
5. After loading the data, you will see that:

* LandingLens created a class based on each sub-directory name (if the classes didn't exist yet).
* Images in each sub-directory will be in LandingLens and will be classified with the name of their directory. For example, in the screenshot below, the "pneumonia" class is assigned to the images.
  <img alt="SyncSF_classify_pneumonia_2" />

## Sample Datasets

LandingLens offers two sample datasets that you can use to practice loading and classifying images from Snowflake stages. These datasets are available as "apps" from the Snowflake Marketplace. Access the datasets here:

* [Sample Dataset for LandingLens: Manufacturing Metal Casting](https://app.snowflake.com/marketplace/listing/GZTYZ12K65C6/)
* [Sample Dataset for LandingLens: LifeSciences Pneumonia](https://app.snowflake.com/marketplace/listing/GZTYZ12K65CA/)

## Troubleshooting the Sync Process

When using **Sync Snowflake Data** tool, you might get this error:

> Failed to load folder list, Failed to list folder. Please follow instruction below to grant permission to the stage.

This error means that you don't have permission to access the Database, Schema, or Stage you selected. To get permission, run the generated SQL commands that display on the pop-up.

<img alt="SyncFailedToLoad" />

## View Syncs from the Past Seven Days

If you've run the **Sync Snowflake Data** tool in a project, you can see the status of all syncs from the past seven days. To do this, click the **Sync** icon near the top right corner LandingLens. A list of all syncs, the synced stages, and statuses display.

Hover over a stage to see the full path of the database, schema, and stage.

If a sync failed, hover over the **i** icon to see more details.

<img alt="SyncStatus_projec" />


# Manage Label Books
Source: https://landinglens.docs.landing.ai/manage-label-book



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

<iframe title="YouTube video player" />

Images need to be labeled consistently. To help Labelers understand how to label images, it is best practice to create a Label Book. A\*\* Label Book\*\* is a living document that allows you to define how to label various categories of Classes clearly.

## Classes Must Be Descriptive

To help Labelers understand how to label images, it is best practice to be as descriptive as possible in the Label Book. The following points are a few examples of information that you can include in a Class description:

* What does the object to be identified look like?
* What parts of the object should be labeled?
* How do you label objects that overlap?
* If you're labeling with bounding boxes, how close should you keep the box to the object?

Let's take a look at the example of washers below.

<img alt="Washers" />

Since Labelers will be looking at two types of washers, it's important to describe each type thoroughly. For instance:

* (Left) Circular hardware with 8 grooves on the inner circle. Keep the bounding box as close as possible to the object without touching it.
* (Right) Circular hardware with 6 grooves on the inner circle. Keep the bounding box as close as possible to the object without touching it.

## Add Descriptions and Images to Classes

It's important to add descriptions and images to Classes. This information will be a reference point to ensure that all users label data similarly.

To add descriptions and images to Classes:

1. Open the Project you want to edit.
2. Click the **Actions** button (ellipses) and select **Manage Classes**.
   <img alt="ManageLabelBook_1" />
3. Click the Class you want to update.
   <img alt="ManageLabelBook_2" />
4. Click **Edit**.
   <img alt="ManageLabelBook_3" />
5. Enter a thorough description of the Class in the field provided.
6. Click an **Add Images option** to upload an example of the Class you are describing. For example, upload an image of this washer type if you are editing a description for a six-tooth washer.
   <img alt="ManageLabelBook_4" />
7. You can update images as needed by hovering over the image and selecting the appropriate icon.
   <img alt="ManageLabelBook_5" />
   * **Delete**: Delete the image.
   * **Edit**: You can add a label (like a bounding box) to the image. Then you can add a description of how to label objects.
     <img alt="ManageLabelBook_6" />
   * **Hide**: If you've added labels to the image using the "Edit" feature, you can hide them by hovering over the "Hide" icon.
     <img alt="Hide" />
8. Click **Save**.


# March 2022 Release Notes
Source: https://landinglens.docs.landing.ai/march-2022-release-notes



## Direct Labeling Control

With the recent addition of Direct Media labeling it's now easier than ever to rapidly label images. However with the improvement comes an increased likelihood of careless labeling and poor ground truth labels.

To help Admins account for this, we've added the ability to limit user access to direct labeling by project. With this access control, Admins can limit users to task based labeling only. This is especially useful with new employees or third party labeling teams who have yet to prove their labels will be consistent with the Defect book.<img alt="rbac_label" />

When adding new users to a private project (Settings>Invite), you'll see a series of checked access controls under "Project Permissions". To revoke direct labeling access, simply uncheck "Direct label" and that user will no longer see the option to label images from the data browser. You can assign a labeling task to these users.

### Direct Image Labeling

When viewing viewing a single image you will see a new UI element at the top left. By default you will be in "View" mode but if you switch to "Label", you can add GT labels directly to each image.

This method will speed up your labeling but be warned, without a reviewer or agreement labeling, there is an increased chance of mislabeled images going unnoticed.

### Splits

We've moved split out of the Metadata section and made it an independent element. You can now adjust split directly in the image view. To Auto Split, from the data browser simply select the three vertical dots next to "Split" and then choose "Auto Split".

## Classification Activation Heatmap

To help with classification error analysis, we've implemented a heatmap "visual explanation" for all classification models. Now when conducting error analysis, users' can see the specific area of each image that caused it to be classified in a specific way.

Here we can see the heatmap highlights the cracked portion of the cement square - this was the area of the image that caused the model to classify this example as "cracked".

You can learn more about the approach [here](https://arxiv.org/abs/1610.02391).

## Training Hour Usage

You can now see your organizations per project GPU training usage by hours. To see how many hours you've spent training models during a month, choose **Projects** > **View Projects**. You'll see the GPU hrs for the current and previous month listed next to each project.

## Pause Cloud Instances

From the device media page you can now pause cloud instances used for deployment. Simply navigate to Devices and choose the vertical three dots under actions on the right of the page.


# May 2022 Release Notes
Source: https://landinglens.docs.landing.ai/may-2022-release-notes



## Upload Segmentation Labeled Media

Users can now upload segmentation labeled images to LandingLens in the Pascal VOC format.

On the segmentation upload screen, switch from "Upload unlabeled media" to "Upload labeled media". This will reveal three types of objects to upload:

* Images you wish to upload
* Segmentation masks that contain the labels for each image
* JSON defect map that matches the images to their corresponding labeled class

Drag or choose the relevant items from your folder and choose "upload media". Once complete, your labeled images will be available for review and model training.

## Edit Labels While Reviewing

Task managers can now edit labels directly in a review task without creating a whole new task. While reviewing a task simply select "Edit" at the bottom right corner and you can make adjustments to the existing labels or create net new ones from scratch. After saving these, any changes made will be recorded for your records later## Re-Assign Rejected Media

Now you can re-assign rejected media to the original labeler with added notes to help them understand how they can improve their label quality. This not only helps improve the ground truth quality but also helps labelers get feedback and improve their labeling abilities.

After reviewing a task, you'll see an option to re-assign the rejected media (with their comments) to the same labelers.


# Add Members
Source: https://landinglens.docs.landing.ai/member-registration



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✖</span></td>
    </tr>
  </tbody>
</table>

To add a user (member) to LandingLens, an Owner or Admin first [invites](#invite-members-to-landinglens) that person. That person then receives an automated email and is prompted to [complete the registration process](#complete-your-registration). Watch the following video to learn more.

<iframe title="YouTube video player" />

## Maximum Number of Members

Your [LandingLens plan](https://landing.ai/pricing/) determines how many members your organization can have. All members that have the status Active or Pending count toward the number of users.

* **Free**: Up to 3 members
* **Visionary**: Up to 15 members
* **Enterprise**: Unlimited

## Invite Members to LandingLens

Only Owners and Admins can invite people to become members. To do this:

1. Go to the **Members** page.
2. Click **Invite Members**.
   <img alt="inviteMembers_1" />
3. The **Invite Members** pop-up window displays. Enter the email address of the person you want to invite in the **Organization Email** field. Email addresses must be lowercase.
4. Select the [Role](./members) you want to give the user from th **Organization Role** drop-down menu.
5. To invite multiple people, click **Add more members**.
6. Click **Invite**. An invitation to join LandingLens is emailed to the listed people.
   <img alt="inviteMembers_2" />

<Info>To invite multiple users at once, click **Add more members** before sending the invitation.</Info>

## Complete Your Registration

After you've been invited to LandingLens, you will receive an automated email prompting you to complete your registration. Your LandingLens account will be linked to the email address this email was sent to. If you want your account to be linked to a different email address, ask the user who invited you to send a new invitation to that address.

To complete your LandingLens registration:

1. Open the automated email from LandingLens.
2. Click the button that prompts you to register. A new window or tab opens.
3. If applicable, you can log in with a Google or Enterprise account.
4. Or, create a new account by entering your name and a new password (see the [password requirements](./passwords)).
5. Accept the Terms of Service.
6. Click **Create LandingLens Account**. The registration process is complete, and you can now log in to LandingLens.
   <img alt="inviteMembers_3" />


# Member Roles
Source: https://landinglens.docs.landing.ai/members



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✖</span></td>
    </tr>
  </tbody>
</table>

Users in LandingLens are called **members**. Only members can access LandingLens. LandingLens offers the following types of member roles: Collaborators, Admins, and Owners.

The following table compares the defining features of each role:

| Feature                                                      | Collaborator | Admin | Owner |
| ------------------------------------------------------------ | ------------ | ----- | ----- |
| Access the Plan & Billing page                               | ✖            | ✓     | ✓     |
| Access the Usage page                                        | ✖            | ✓     | ✓     |
| Access the Members page                                      | ✖            | ✓     | ✓     |
| Access the API Key page                                      | ✖            | ✓     | ✓     |
| Deactivate members                                           | ✖            | ✓     | ✓     |
| Change Collaborators to Admins                               | ✖            | ✓     | ✓     |
| Change the roles of all members                              | ✖            | ✖     | ✓     |
| Access the Project Access page (can override project access) | ✖            | ✖     | ✓     |
| Manage (move, rename, delete) any folder                     | ✖            | ✓     | ✓     |

### Collaborators

An organization can have multiple Collaborators.

Users with this role have limited access to LandingLens. They can create projects, upload images, deploy models, and more. Collaborators can view folders and move their own projects into folders, but cannot create, move, rename, or delete folders.

Collaborators don't have access to the administrative pages (**Plan and Billing**, **Usage**, **Members**, and **API Key**). For example, the following screenshot shows what a Collaborator sees in their User Menu.

<img alt="collaborator_settings" />

### Admins

An organization can have multiple Admins.

Users with this role have all the access as Collaborators *and*:

* Can create, move, rename, and delete folders
* Can access the administrative pages
* Can change Collaborators to Admins
* Can deactivate members
* Can access the administrative pages (**Plan and Billing**, **Usage**, **Members**, and **API Key**). For example, the following screenshot shows that an Admin can see the administrative pages in their User Menu.

<img alt="admin_settings_callout" />

### Owners

Users with the Owner role have all the access as Admins (including creating and managing folders) *and* can change the roles of all other members. For the Enterprise plan, Owners can also manage project access in the [Project Access](./override-project-access) page.

The user who creates an organization is automatically assigned to the Owner role.

The number of Owners your organization can have depends on your LandingLens plan:

* **Enterprise**: Can have multiple Owners
* **Free**: Can have up to 3 Owners

<Info>Only organizations created after October 10, 2023 will automatically assign the Owner role to the organization creator. If your organization was created before this date, and you would like to assign someone to the Owner role, contact your representative. If your organization doesn't have the Owner role, Admins can deactivate members.</Info>

## Change Member Role

Owners can change the roles of any member. Admins can "upgrade" Collaborators to Admins, but they can't change any other roles.

To change the role of another member:

1. Click the **User Menu** and select **Members**.
   <img alt="user_menu_members" />
2. Locate the account of the member. (You may need to search for the member to narrow down the list of users.)
3. Click the **Settings** button (vertical ellipses) and select **Change User Role To Admin** or **Change User Role To Collaborator**.
   <img alt="members_make_admin" />
4. The new role is assigned to the member.

## Change Ownership

An Owner can transfer ownership to an Admin. "Transferring ownership" means that the Admin becomes the Owner. As a reminder, an organization can have up to three Owners.

To transfer Ownership:

1. Click the **User Menu** and select **Members**.
   <img alt="user_menu_members" />
2. Locate the account of the member. (You may need to search for the member to narrow down the list of users.)
3. Click the **Settings** button (vertical ellipses) and select **Transfer Organization Ownership**.
   <img alt="members_make_owner" />
4. That user becomes the Owner, and you become an Admin.

<Info>Ownership can only be transferred to an Admin. If you want a Collaborator to become the Owner, you must first "upgrade" them to an Admin role.</Info>

## Automatic Logout

A member is automatically logged out of LandingLens after 30 days of inactivity.


# Members
Source: https://landinglens.docs.landing.ai/members-intro



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✖</span></td>
    </tr>
  </tbody>
</table>

Users in LandingLens are called **members**. Only members that have been invited to your LandingLens organization can access it.

Members are managed on the **Members** page. From the Members page, you can:

* [Add (register) members](./member-registration)
* [Deactivate and reactivate members](./deactivate-member-accounts)
* [Change member roles](./members)
* [View member statuses](./view-members)

<img alt="View and Manage Members" />

To access the Members page, click the **User Menu** and select **Members**.

<img alt="Open the Members Page" />


# Mobile Inference
Source: https://landinglens.docs.landing.ai/mobile-inference



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✖</span></td>
    </tr>
  </tbody>
</table>

&#x20;is excited to share that we’ve developed a new feature—! This feature empowers you with an additional way to use LandingLens models in the real-world.

After you develop a model and deploy it to an endpoint, you can then generate a QR code. Scanning the QR code with your phone opens the LandingLens app in your browser.

From there, you can take a photo or select a photo from your phone. The app sends the photo to the cloud-hosted model to run inference on it, and then the results display immediately on your phone! If you're using  for an Object Detection project, you'll also see the number of objects detected.

The images and predictions are saved back to LandingLens, so that you can review all results in a centralized location. You can also share the QR code with your colleagues, so that you can all collaborate on running inference.

<iframe title="YouTube video player" />

<Info>You can run inference up to 40 times per minute per endpoint. If you exceed that limit, the API returns a `429 Too Many Requests` response status code. We recommend implementing an error handling or retry function in your application. If you have questions about inference limits, please contact your LandingAI representative or [sales@landing.ai](mailto:sales@landing.ai).</Info>

## Use Mobile Inference

&#x20;is a part of Cloud Deployment. To use , you first deploy to an endpoint, which is the virtual device that will host the model.

To use :

1. Set up an [endpoint](./cloud-deployment#set-up-endpoints), as you would for Cloud Deployment.
2. After creating an endpoint, the  tile appears on the right side of your screen (you might have to scroll over to see it). In this tile, click **Get QR Code**.
   <img alt="mobile_app_getQRcode" />
   <Info>If you've already run inference, the tile no longer displays. Instead, click the QR Code icon next to the endpoint name to open the QR Code pop-up window.<br /><img alt="mobile_app_scan_QRcode" /></Info>
3. A pop-up window opens with a QR code that is unique to this deployment.
4. Turn on your phone’s camera app, and hold up your phone to the QR code.
5. Click the pop-up that appears at the top of your phone.
   <img alt="mobile_app_scan_QRcode" />
6. The LandingLens app opens in your browser. Click **Select a Photo** and select one of these options to get an image:
   * **Photo Library**: Select an image saved to your phone.
   * **Take Photo**: Use the Camera app on your phone to take a photo.
   * **Choose File**: Select a file saved to your phone.
     <img alt="select_photo" />
7. After you select or take a photo, the app sends the photo to the deployed model, and the model runs inference on it. The model’s predictions show up almost instantaneously as overlays on your phone. If you're using  for an Object Detection Project, you'll also see the number of objects detected.
   <img alt="mobile_app_predictions" />
8. If you have more samples lined up, you can keep taking photos and running predictions–just click **Select a Photo** to continue.
9. When you're done running inference, you can close the tab on your browser.
10. All the photos you’ve taken and their predictions display on the **Deploy** page back in LandingLens. This set includes results from all the ways you ran inference for this deployment, including via APIs *and* .
    <img alt="mobile_app_historic_data" />

## Deactivate a QR Code

You can deactivate the QR code for  at any time by clicking **Turn It Off** on the QR code pop-up window. When the QR code is deactivated, no one with the QR code can use it to run inference.

<img alt="turnitoff" />

Deactivating the QR code can be useful in multiple situations. For example, you can deactivate it if you have a time-bound project, and don't want to add more data after the end of the project.

To reactivate a QR code, simply follow the procedure in [Use ](./mobile-inference#use-variablemi).


# Model Reports
Source: https://landinglens.docs.landing.ai/model-settings



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

Each model you train in a project displays as a tile in the **Model List** on the right of the **Build** page. Each model tile shows high-level performance metrics, including the F1 or IoU score for each split.

<img alt="ModelList_Feb_2025" />

## Analyze Model Performance

Watch the following video to learn how to use the model report metrics and confusion matrix to analyze and improve model performance.

<iframe title="YouTube video player" />

## Model List Overview

Here's a quick introduction to the elements of the Model List:

<img alt="ModelTile_Overview_Feb_2025(1)" />| # | Item | Description |
\| --- | --- | --- |
\| 1 | Model List | Click the **Model List** button to show/hide the model tiles. |
\| 2 | Name | The model name. |
\| 3 | Performance scores for splits | The performance score for each split. Object Detection, Classification, and Anomaly Detection projects show the [F1 score](./model-settings#object-detection-and-classification-f1-score). Segmentation projects show the [Intersection over Union (IoU) score](./model-settings#segmentation-intersection-over-union-iou). |
\| 4 | More Actions | Click the **Actions** icon (**...**) to access these tools or shortcuts: [Download CSV](./model-settings#download-csv-model-performance-for-each-image-in-dataset), [View on Models Page](./model-settings#view-on-models-page), [Go to Snapshot Page](./model-settings#go-to-snapshot-page). |
\| 5 | Predictions | The number of times the model made each of these predictions: False Positive, False Negative, Misclassified, and Correct. (Some predictions aren't applicable to certain project types.)<br /><br />For Segmentation projects, the number is the number of *pixels*. |
\| 6 | View Confusion Matrix | Click [View Confusion Matrix](./model-settings#view-confusion-matrix) to see the model performance metrics and confusion matrix. The data is based on the dataset that the model was trained on. |
\| 7 | Try Model | Click [Try Model](./model-settings#try-model) to see how the model performs on new images. |
\| 8 | Collapse and expand tile | Click to show/hide the predictions. |
\| 9 | Load more models | Click the **Load** button to show more model tiles. |

## View Confusion Matrix

Click **View Confusion Matrix** to see the model [performance](./model-settings#performance) metrics and [confusion matrix](./model-settings#confusion-matrix).

### Performance

<img alt="Performance_OD_Feb_2025" />

The **Performance** section shows how the model performed on the Train, Dev, and Test sets (see more information about [splits](./splits) here). The number in parentheses is the number of images in the split.

For Object Detection, Segmentation, and Anomaly Detection projects, the scores are based on the confidence threshold that displays. This is the confidence threshold with the best F1 score for all labeled data.

The Performance score unit depends on the project type:

* [Object Detection, Classification, Anomaly Detection: F1 Score](./model-settings#object-detection-classification-anomaly-detection-f1-score)
* [Segmentation: Intersection Over Union (IoU)](./model-settings#segmentation-intersection-over-union-iou)

#### Object Detection, Classification, Anomaly Detection: F1 Score

The Performance section for Object Detection, Classification, and Anomaly Detection projects shows the F1 score for each split.

<img alt="Performance_OD_Feb_2025" />

For **Object Detection**, the F1 score combines precision and recall into a single score, creating a unified measure that assesses the model’s effectiveness in minimizing false positives and false negatives. A higher F1 score indicates the model is balancing the two factors well. LandingLens uses micro-averaging to calculate the F1 score.

For **Classification** and **Anomaly Detection**, the F1, Precision, and Recall scores are identical. This is because these models have only two prediction outcomes: "Correct" and "Misclassified". Therefore, the F1, Precision, and Recall scores for these models are all calculated using this algorithm:

$$
\frac{Corrects}{Misclassifieds}
$$

#### Segmentation: Intersection Over Union (IoU)

The Performance section for Segmentation projects shows the Intersection over Union (IoU) score for each split.

<img alt="Performance_SEG_Feb_2025" />

Intersection over Union (IoU) is used to measure the accuracy of the model by measuring the overlap between the predicted and actual masks in an image. A higher IoU indicates better agreement between the ground truth and predicted mask. LandingLens does not include the implicit background and micro-averaging in the calculation of the IoU.

#### Precision

Select **Precision** from the drop-down in the **Performance** section to see the Precision scores for each split.

<img alt="Precision_OD_Feb_2025" />

**Precision** is the model’s ability to be accurate when it says something is true. Precision answers the natural language question, “When the model makes a prediction, how often is it correct?” This metric shows how accurate the model predictions are. The higher the Precision score, the more accurate the predictions are.

For **Object Detection** and **Segmentation**, Precision is calculated using this algorithm:

$$
Precision = \frac{TruePositives}{TruePositives + FalsePositives}
$$

For **Classification** and **Anomaly Detection**, the F1, Precision, and Recall scores are identical. This is because these models have only two prediction outcomes: "Correct" and "Misclassified". Therefore, the F1, Precision, and Recall scores for these models are all calculated using this algorithm:

$$
\frac{Corrects}{Misclassifieds}
$$

#### Recall

Select **Recall** from the drop-down in the **Performance** section to see the Recall scores for each split.

<img alt="Recall_OD_Feb_2025" />

**Recall** is the model’s ability to find all objects of interest. Recall answers the natural language question, “Of all the labels (ground truths) in the dataset, what percent of them are found by the model?” It conveys how accurately the model can correctly identify all the actual positive instances in the dataset. The higher the Recall score, the lower the chance the model will have a false negative.

For **Object Detection** and **Segmentation**, Recall is calculated using this algorithm:

$$
Recall = \frac{TruePositives}{TruePositives + FalseNegatives}
$$

For **Classification** and **Anomaly Detection**, the F1, Precision, and Recall scores are identical. This is because these models have only two prediction outcomes: "Correct" and "Misclassified". Therefore, the F1, Precision, and Recall scores for these models are all calculated using this algorithm:

$$
\frac{Corrects}{Misclassifieds}
$$

### Confusion Matrix

Click **View Confusion Matrix** on a model tile to see the confusion matrix.

<img alt="ModelList_ViewConfusionMatrix" />

The confusion matrix counts ground truth labels versus model predictions. The confusion matrix shown here is for the *dataset that the model was trained on*.

The y-axis represents each ground truth label. The x-axis represents each possible model prediction.

Each cell shows the count of instances that correspond to a particular ground truth class-predicted class pair. For example, in the image below, the model correctly predicted the class "Hard Hat" 32 times and misclassified it 2 times.

<img alt="ConfusionMatrix_ModelList_OD" />

### Precision Score for Class

The Precision score for each class is listed along the x-axis. Precision answers the natural language question, “When the model predicts Class A, how often is it correct?”

The Precision score for a class is the percentage of instances that the model correctly predicted the class out of all instances that the model predicted the class, and is calculated using this equation:

$$
Precision_A = \frac{TruePositives_A}{TruePositives_A + FalsePositives_A}
$$

For example, let’s calculate the Precision score for the Wheat class in the image below. The model predicts Wheat 7 times. Of those, 6 are correct (True Positives) and 1 is incorrect (False Positives). When we plug those numbers into the Precision equation, we see that the Precision for this class is 85.7%.

$$
= \displaystyle\frac{6}{6 + 1}
$$

$$
= 85.7\%
$$

<img alt="Precision Score for Wheat" />

### Recall Score for Class

The Recall score for each class is listed along the y-axis. Recall answers the natural language question, “Of all the Class As in the dataset, what percent of them are found by the model?”

The Recall score for a class is the percentage of instances that the model correctly predicted the class out of all actual instances of the class, and is calculated using this equation:

$$
Recall_A = \frac{TruePositives_A}{TruePositives_A + FalseNegatives_A}
$$

For example, let’s calculate the Recall score for the Wheat class in the image below. The dataset has 8 instances of Wheat. The model predicts 6 instances correctly (True Positives) and 2 instances incorrectly (False Negatives). When we plug those numbers into the Recall equation, we see that the Recall for this class is 75.0%.

$$
= \displaystyle\frac{6}{6 + 2}
$$

$$
= 75.0\%
$$

<img alt="Recall Score for Wheat" />

### Use Colors to Help Interpret Performance

Each cell has a color that can quickly help you identify correct classifications and errors. Darker colors indicate a higher number, and lighter colors indicate a lower number.

For example, if the model correctly predicts all instances, only the cells on the diagonal will be blue and have non-zero values. See the following image as an example.

<img alt="All Correct Predictions" />

If any off-diagonal cells contain values, start by looking for the darker colors to understand where the model is making errors. For example, let’s say you want to evaluate performance for the Rice class using the confusion matrix below. The model correctly predicted 1 instance and misclassified 3 instances. Consider looking at the instances that were misclassified as Corn first, since that cell is darker (and has a higher number) than the Wheat cell.

<img alt="Some Incorrect Predictions" />

## Try Model

After you train a model, you can test its performance by using the **Try Model** tool. Using Try Model is a good way to "spot-check" a model's performance.

When you click **Try Model**, you can upload a few images to see how the model performs on them. Ideally, you should upload images that aren't already in the dataset and that match your real-world use case. If the model performs well on the new images, you can [deploy it](./deployment-options). If the model doesn't perform well on the images, try uploading and labeling more images in your project. Then run Try Model again.

The Try Model tool runs inference on each image, so using this tool costs 1 credit per image. (The credit cost is not applicable when using .)

To use **Try Model**:

1. Open a project to the **Build** tab.
2. Click **Model List** to view all models in the project.
3. Click **Try Model** on the model you want to use. (You can also click a model tile to open the model, and then click **Try Model**.)
   <img alt="TryModel_Feb_2025_1" />
4. Upload images.
   <img alt="TryModel_2" />
5. LandingLens runs the model and shows you the results. Adjust the **Confidence Threshold** slider (for Object Detection and Segmentation) or **Anomaly Threshold** slider (for Anomaly Detection) to see how the model performs with different thresholds. Typically, a lower threshold means that you will see more predictions, while a higher threshold means you will see fewer.
   <img alt="TryModel_3_confidence" />

## Download CSV of Model Predictions

For Object Detection, Classification, and Anomaly Detection projects, you can download a CSV that shows the ground truth labels and model predictions for images. You can download the CSV:

* [For images in a model dataset](./model-settings#download-csv-model-predictions-for-images-in-a-model-dataset)
* [For select images](./model-settings#download-csv-model-predictions-for-select-images)

### Download CSV: Model Predictions for Images in a Model Dataset

You can download a CSV of model predictions for the dataset of images that a model was trained on. This is available for Object Detection, Classification, and Anomaly Detection projects.

The prediction data in the CSV is based on the selected model and the threshold saved on that model.

To download the CSV for images in a model's dataset:

1. Open a project to the **Build** tab.
2. Click **Model List** to view all models in the project.
3. Click the **Actions** icon (**...**) on the model tile and click **Download CSV**. (You can also click a model tile to open the model, and then click **Download CSV**).
   <img alt="ModelList_DownloadCSV_Feb_2025" />
4. The file is downloaded to your computer. For a description of all data in the file, go to [CSV Data](./model-settings#csv-data).

### Download CSV: Model Predictions for Select Images

You can download a CSV of model predictions for select images in your Object Detection, Classification, or Anomaly Detection dataset.

The prediction data in the CSV is based on the selected model and threshold. If you manually change the threshold, that threshold is used in the CSV.

If a model hasn't been created in the project yet, the prediction fields in the CSV will be blank.

To download the CSV for select images in a dataset:

1. Open a project to the **Build** tab.
2. Select the model you want to see the predictions for from the **Prediction/Model** drop-down menu.
   <img alt="DownloadCSV_SelectImages_0" />
3. Select the images you want to download the CSV for.
4. Click **Options** in the action bar near the bottom of the screen and select **Download CSV**.
   <img alt="DownloadCSV_SelectImages_1" />
5. Click **Download** on the pop-up window that opens.
   <img alt="DownloadCSV_SelectImages_2" />
6. The file is downloaded to your computer. For a description of all data in the file, go to [CSV Data](./model-settings#csv-data).

### Download CSV with the API

You can use the API to download the CSV for [the images in a model's dataset](./model-settings#download-csv-model-predictions-for-images-in-a-model-dataset), instead of downloading it from the app. The API doesn't have an equivalent for the select-images CSV. Use this endpoint to get a download link for the file:

```http theme={null}
GET /v1/projects/{project_id}/train/{training_id}/results/per-sample-report
```

The `training_id` is the Model ID that displays under the model name on the Models page. To find it, go to [Get the Model ID for the API](./models-page#get-the-model-id-for-the-api).

The endpoint returns a download link and the time the link expires:

```json theme={null}
{
  "data": {
    "downloadUrl": "https://...",
    "downloadExpiresAt": "20240101T010000Z"
  }
}
```

The CSV covers every image in the snapshot the model was trained on, across all splits. Predictions use the threshold saved on the model.

This endpoint supports Object Detection, Classification, and Anomaly Detection projects. It doesn't support Segmentation projects.

Get more information about this API in [Get Per Sample Report](https://landing-ai.github.io/public-rest-api/fastapi/#/operations/get_per_sample_report_v1_projects__project_id__train__training_id__results_per_sample_report_get).

### CSV Data

| Item                                       | Description                                                                                                                                                                                     | Example                                                                            |
| ------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------- |
| Project Name                               | Name of the LandingLens project.                                                                                                                                                                | Defect Detection                                                                   |
| Project Type                               | Project type ("bounding\_box" is Object Detection).                                                                                                                                             | classification                                                                     |
| Image Name                                 | The file name of the image uploaded to LandingLens.                                                                                                                                             | sample\_003.jpg                                                                    |
| Image ID                                   | Unique ID assigned to the image.                                                                                                                                                                | 29786892                                                                           |
| Split                                      | The split assigned to the image.                                                                                                                                                                | train                                                                              |
| Upload Time                                | The time the image was uploaded to LandingLens. All times are in Coordinated Universal Time (UTC).                                                                                              | Mon Jun 26 2023 16:37:10 GMT+0000 (Coordinated Universal Time)                     |
| Image Width                                | The width (in pixels) of the image when it was uploaded to LandingLens.                                                                                                                         | 4771                                                                               |
| Image Height                               | The height (in pixels) of the image when it was uploaded to LandingLens.                                                                                                                        | 2684                                                                               |
| Model Name                                 | The name of the model in LandingLens.                                                                                                                                                           | 100% Precision and Recall                                                          |
| Metadata                                   | Any metadata assigned to the image. If the image doesn't have any metadata, the value is "".                                                                                                    | `{"Author":"Eric Smith","Organization":"QA"}`                                      |
| GT\_Class                                  | The Classes you assigned to the image (ground truth or “GT”). For Object Detection, this also includes the number of objects you labeled.                                                       | `{"Screw":3} `                                                                     |
| PRED\_Class                                | The Classes the model predicted. For Object Detection, this also includes the number of objects predicted. If the model didn't predict any objects, the value is `{"null":1}`.                  | `{"Screw":2} `                                                                     |
| Model\_Correct                             | If the model's prediction matched the original label (ground truth or “GT”), the value is true. If it didn't match, the value is false. Only for Classification and Anomaly Detection projects. | true                                                                               |
| PRED\_Class\_Confidence / PRED\_Confidence | The model's Confidence Score for each object predicted. If the model didn't predict any objects, the value is .                                                                                 | `[{"Screw":0.94796216},{"Screw":0.9787127}]`                                       |
| Model\_Confidence                          | The Anomaly Threshold set on the model. This is a property of the model, so the value is the same for every image in the file. Only for Anomaly Detection projects.                             | 0.56                                                                               |
| Class\_TotalArea                           | The total area (in pixels) of the model's predicted area. If the model didn't predict any objects, the value is . Only for Object Detection projects.                                           | `{"Screw":76060}`                                                                  |
| GT-PRED JSON                               | The JSON output comparing the original labels (ground truth or "GT") to the model's predictions. See the JSON Output link for details.                                                          | `{"gtDefectName":"No Fire","predDefectName":"No Fire","predConfidence":0.9684047}` |
| THRESHOLD                                  | The confidence threshold for the model applied to the dataset. This column is only included when downloading the CSV for select images.                                                         | 0.09                                                                               |

## View on Models Page

To adjust the threshold, view visual predictions, or compare the model to other models in the same project, open the model in the [Models tab](./compare-models).

The Model List has a few shortcuts to the Models tab:

* Click the **Actions** icon (**...**) on the model tile and click **View on Models Page**.
* Click **View Confusion Matrix** on a model tile and click **View Full Report**.
* Click **View Confusion Matrix** on a model tile, click the **Actions** icon (**...**) and click **View on Models Page**.

## Go to Snapshot Page

The Model List has a few shortcuts to the [Snapshot page](./dataset-snapshots):

* Click the **Actions** icon (**...**) on the model tile and click **Go to Snapshot Page**.
* Click a model tile, click the **Actions** icon (**...**) and click **Go to Snapshot Page**.


# Models
Source: https://landinglens.docs.landing.ai/models



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

After you have labeled your images, you can train a *computer vision model*, also simply called a "model". A **model** is a computational representation that predicts objects or certain characteristics that it was trained to detect. When you train a model, you give your labeled images to a deep learning algorithm. This allows the AI to "learn" what to look for in images.

For example, let's say you manufacture metal sheets, and you want to detect scratches. You can use LandingLens to build a computer vision model that detects scratches. When you train a model, it will scan through your images multiple times to learn how to detect scratches. You can then deploy that model to your production environment.

<img alt="model_OD" />


# Models Page
Source: https://landinglens.docs.landing.ai/models-page



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

<iframe title="YouTube video player" />

Use the **Models** page to analyze and compare model performance across multiple datasets in a project. The Models page gives you the tools to:

* **Analyze how a model performed**. Quickly see how the model performed on its Train, Dev, and Test sets. You can also view the model's Loss chart, Validation chart, F1 or IoU score, and predictions. For more information, go to [Model Information](./models-page#model-information).
* **See how a model performs on different datasets**. When you train a model, you can see how it performed on the dataset it was trained with. On the Models page, you can add more datasets (called "evaluation sets") and run the models on those images to see how the model performs. To get started, go to [Evaluation Sets](./models-page#evaluation-sets).
* **Compare two models**. When you run a model comparison, LandingLens shows you the differences in F1 or IoU score and the number of correct and incorrect predictions. You can use this information to fine-tune your labels, datasets, and hyperparameters. To compare models, go to [Compare Models](./compare-models).
* **Deploy models**: After analyzing and comparing model performance, choose which model or models you want to deploy. Go to [Cloud Deployment](./cloud-deployment).

<img alt="modelspage_overview_03_2024(1)" />

<Info>Due to the unique nature of [Visual Prompting](./visual-prompting), the Models tab is not available for Visual Prompting projects.</Info>

## How do I use the Models table to see what model is the best for my project?

You can use the **Models** table to quickly evaluate model performance across different datasets. You can also see how the same model—but with different confidence thresholds—performs on the same datasets.

There is no one-size-fits-all solution, but quickly comparing model performance can help you identify 1) what model works best for your use case and 2) what models might need better images or labels.

Here are some considerations:

* If two models have the same confidence threshold but different scores on the same datasets, view the predictions for the model with the lower score. Are the labels correct? Do you need more images of a specific class?
* If a model has a higher score on a dataset that is most like your real-world scenario, that model might be the best one for your use case.

## Models Table Overview

Here's a quick orientation to the Models table:

<img alt="modelspage_callouts_03_2024" />

| # | Item                                                                                                                 | Description                                                                                                                                                                                                                                                                                                                                                                                  |
| - | -------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| 1 | [Model](./models-page#model-information)                                                                             | The model name, [Model ID](./models-page#get-the-model-id-for-the-api), and training method (customized or default).                                                                                                                                                                                                                                                                         |
| 2 | [Evaluation sets](./models-page#evaluation-sets)                                                                     | These columns consist of your evaluation sets, which are sets of images used to evaluate model performance.<br /><br />The model's Train, Dev, and Test sets display by default. You can add more datasets and run the models on those sets.<br /><br />Shows the F1 score (for Object Detection, Classification, and Anomaly Detection projects) and IoU score (for Segmentation projects). |
| 3 | [Confidence Threshold](./models-page#confidence-threshold)<br />[Anomaly Threshold](./models-page#anomaly-threshold) | For Object Detection and Segmentation projects, the [Confidence Threshold](./models-page#confidence-threshold) displays.<br />For Anomaly Detection projects, the [Anomaly Threshold](./models-page#anomaly-threshold) displays.                                                                                                                                                             |
| 4 | [Deployment](./models-page#cloud-deployment)                                                                         | Deploy the model via [Cloud Deployment](./cloud-deployment). If the model has been deployed with Cloud Deployment, an icon for each endpoint displays.                                                                                                                                                                                                                                       |
| 5 | [More Actions](./models-page#more-actions)                                                                           | Favorite, deploy, and delete models. Can also copy the Model ID.                                                                                                                                                                                                                                                                                                                             |

## Model Information

The **Model** column displays the model name, the [Model ID used by the API](./models-page#get-the-model-id-for-the-api), and the training method:

* **Default configuration**: Trained using [Fast Training](./train-models).
* **Customized configuration**: Trained using [Custom Training](./custom-training).

<img alt="modelspage_models_03_2024_1" />

Click the cell to see the model's [Training Information](./training-information) and [Performance Report](./performance-report).

A model can have multiple rows. For example, if you deploy a model and select a confidence score that is not the default one, then two rows for the model display in the table. The first row has the default confidence threshold, and the second has the custom confidence threshold.

For example, in the screenshot below, the default confidence threshold is 0.71, and the custom confidence threshold is 0.99.

<img alt="modelspage_models_2" />

## Evaluation Sets

The Models table shows how each model performs on different sets of images. These image sets are called *evaluation sets*, because they're used to *evaluate* model performance.

The default evaluation sets are the Train, Dev, and Test splits for the models. You can [add evaluation sets](./models-page#add-evaluation-sets-and-run-models-on-them).

Click a cell to see the [Performance Report](./performance-report) for that evaluation set.

<img alt="modelspage_evalsets(1)" />

### Evaluation Set Scores

A good indication that a model performs well is that its **Train** and **Dev** set scores are high and similar to each other.

The score for the **Train** set might be higher than the scores for the other splits, because these are the images that the model trains on. It is normal for the **Train** set score to be less than 100% because models usually make mistakes during the training process.

In fact, a score of 100% on the **Train** might indicate overfitting, especially if the **Dev** set score is much lower. If the two scores are very different, try adding more images to these sets.

Similarly, the score for the **Test** set might be lower than the scores for the other splits, because the model is not trained on these images.

The following image and table explain the evaluation set scores.

<img alt="modelspage_eval_scores(1)" />

| # | Item       | Description                                                                                                                                                                                                                                                                       |
| - | ---------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| 1 | Percentage | Shows the F1 score (for Object Detection, Classification, and Anomaly Detection projects) and IoU score (for Segmentation projects). Learn more about these scores in [Overall Score for the Evaluation Set](./performance-report#overall-score-for-the-evaluation-set).          |
| 2 | --         | The subset doesn't have any images.<br /><br />If you don't assign splits to a dataset before you train a model, LandingLens automatically assigns images to the Train and Dev splits, but not the Test split. Therefore, you will see "--" for the Test split in that situation. |
| 3 | Blank      | The model hasn't run on the set yet. To run the model, hover over the cell and click **Evaluate**. For more information, go [here](./models-page#run-the-model-on-a-blank-set).                                                                                                   |

### Run the Model on a "Blank" Set

If an evaluation set cell is blank, hover over the cell and click **Evaluate**. The model runs inference on the images in that evaluation set and displays the score.

<img alt="modelspage_run_eval(1)" />

### Add Evaluation Sets and Run Models on Them

By default, each model's performance score for its Train, Dev, and Test set scores displays in the Models table. You can add more datasets. These are called *evaluation sets*, because they're used to *evaluate* model performance.

To add an evaluation set:

1. Open the project to the **Models** tab.
2. Click **Add Evaluation Set**. If you've already dismissed this message, click **+** in the table header.
   <img alt="add_eval_set_1(1)" />
   <img alt="add_eval_set_2" />
3. Select a snapshot.
4. If you want to run the model only on one of the splits, click that split.
5. Click **Add to the Table**.
   <img alt="add_eval_set_3" />
6. LandingLens adds a column for that dataset. To run a model on the dataset, hover over the cell and click **Evaluate**. (To prevent slowing down the system, LandingLens doesn't automatically run each model on the evaluation sets. Click **Evaluate** for each model / evaluation set combination that you want to run.)
   <img alt="add_eval_set_4" />
7. The model runs inference on the images in that evaluation set and displays the [F1 or IoU score](./performance-report#overall-score-for-the-evaluation-set).
   <img alt="add_eval_set_5" />
8. Click the percentage to open the [Performance Report](./performance-report).
   <img alt="add_eval_set_6" />

### Archive Evaluation Sets

You can archive evaluation sets. This removes the evaluation set column from the Models table. You can later [add the evaluation set](./models-page#add-evaluation-sets-and-run-models-on-them) to the table again.

To archive an evaluation set:

1. Open the project to the **Models** tab.
2. Hover of the area to the left of the evaluation set name.
3. Click the **Archive** icon that appears.
   <img alt="archive_eval_set" />
4. Click **Yes** on the pop-up window to confirm the action.

## Confidence Threshold

The **Confidence Threshold** column shows the Confidence Threshold for that model.

The *confidence score* indicates how confident the model is that its prediction is correct.

The *confidence threshold* is the minimum confidence score the model must assign to a prediction in order for it to believe that its prediction is correct. Typically, a lower confidence threshold means that you will see more predictions, while a higher confidence threshold means you will see fewer.

When LandingLens creates a model, it selects the confidence threshold with the best F1 score for all labeled data.

Confidence thresholds are only applicable to Object Detection and Segmentation projects.

<img alt="modelspage_confidence" />

## Anomaly Threshold

The **Anomaly Threshold** column shows the Anomaly Threshold for that model.

Anomaly Detection models have an *anomaly threshold*, which determines if an image is classified as Normal or Abnormal.

Each pixel in the image has an abnormality score. If any pixel's score exceeds the anomaly threshold, the image is classified as Abnormal.

## Cloud Deployment

The Deployment column allows you to deploy a model via [Cloud Deployment](./cloud-deployment), and to see how many times the model has been deployed via Cloud Deployment.

To start the deployment process, click the **Deploy** or **+** button in the **Deployment** column. For more information, go to [Cloud Deployment](./cloud-deployment).

A Cloud icon displays for each deployment. Click an icon to see the deployment details for the model. LandingLens cycles through seven colors for the Cloud icon.

<img alt="modelspage_deployment_2" />

<Info>Icons don't display forLandingEdgeorDockerdeployments.</Info>

## More Actions

In the last column, you can:

* [Favorite models](./models-page#favorite-models)
* [Copy the Model ID for Docker](./models-page#get-the-model-id-for-docker)
* [Delete models](./models-page#delete-models)

<img alt="modelspage_more_03_2024" />

### Favorite Models

To mark a model as a "favorite", click the **Favorite** (star) icon. This changes the star color to yellow, so that you can easily see which models in the table you've marked as favorites. You can favorite multiple models. To unfavorite a model, click the **Favorite** icon again.

<img alt="modelspage_favorite_03_2024_1" />

To filter by favorites, select the **Only show favorite models** checkbox.

<img alt="modelspage_favorite_03_2024_2" />

### Get the Model ID for Docker

Use this ID in the command that [deploys the model with Docker](./landingedge/docker-deploy). It tells the application which model to download from LandingLens.

This ID identifies the model *at the threshold shown in the table*. If you change the threshold, this ID changes.

To copy this ID, click the **Actions** (...) icon and select **Copy Model ID**.

<img alt="copy-bundle-id" />

<Info>This is not the same ID that displays under the model name. To learn about that one, go to [Get the Model ID for the API](./models-page#get-the-model-id-for-the-api).</Info>

### Get the Model ID for the API

Use this ID with the [LandingLens API](./sdk#rest-apis), where it's called `model_id` in some endpoints and `training_id` in others.

This ID identifies the trained model. It's the same ID no matter which threshold you use.

To copy this ID, click the **Copy** icon next to the ID that displays under the model name in the **Model** column.

<img alt="copy-model-id-for-api" />

<Info>This is not the same ID that the **Copy Model ID** option copies. To learn about that one, go to [Get the Model ID for Docker](./models-page#get-the-model-id-for-docker).</Info>

### Delete Models

You can delete a model from the table. This action removes the model *only* from the table; you can still deploy it and access it from other areas in LandingLens, like [Dataset Snapshots](./dataset-snapshots).

To delete a model, click the **Actions** (...) icon and select **Delete**. A model can't be re-added to this table after it's been deleted.

<img alt="modelspage_delete_03_2024" />


# November 2022 Release Notes
Source: https://landinglens.docs.landing.ai/november-2022-release-notes



## What's New

There are no new features to share this month, but we promise that we're working hard behind the scenes to ensure LandingLens and LandingEdge are running as expected. We're also hammering away at some exciting features soon to come! Furthermore, we've recently published these new articles:

* [Deployment Options](./deployment-options)
* Monitoring for Cloud Inference (this has since been deprecated)
* [LandingLens Login](./landinglens-login)
* [Organizations](./organizations)

If you notice anything unexpected, as always, reach out to your  representative.


# Object Detection
Source: https://landinglens.docs.landing.ai/object-detection



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

<iframe title="YouTube video player" />

**Object Detection** offers bounding boxes (rectangles) to outline the objects you want to detect. This project type is commonly used for the following:

* Tracking
* Counting
* Understanding the locations of objects
* Identifying objects and object types

<img alt="Bounding Box" />

## Keep Bounding Boxes Tight Around Objects

It is important to keep bounding boxes as close to the object you want to identify as possible. This method will help you avoid capturing unimportant areas, like the background. During model training, the model will look at every pixel inside a bounding box. If you include extra, unimportant pixels, the model might think these pixels are also important. This may cause complications when the model is deployed and is looking for objects in the real world.

For example, in the image below, the two wind turbines are labeled with one bounding box. While this approach successfully captured both wind turbines, it also included a significant amount of background.

<img alt="Bad Bounding Box" />

The image below shows an improved labeling strategy where two bounding boxes are used to label each wind turbine. This method ensures a more focused and accurate representation of wind turbines, minimizing the inclusion of irrelevant areas.

<img alt="Good Bounding Box" />

## Label Images with Bounding Boxes

To label images with bounding boxes:

1. Open the object detection project you want to label images for.
2. Click to open an image.
3. Click the bounding box tool if it's not already selected.
   <img alt="Bounding Box Tool" />
4. Use the guides to line where you want to start the bounding box.
5. Click and drag the box around the object of interest.
6. If you drew this bounding box before you've created a Class, LandingLens prompts you to enter a name for the class.
   <img alt="Label with Bounding Boxes" />
7. Continue labeling all objects of interest.
   <img alt="Label All Objects" />

## Delete Bounding Boxes

Let's say you accidentally added a label that doesn't belong. You can delete that label. To do this:

1. Open the image that has the label you want to delete.
2. Click the bounding box you want to delete. When selected, the bounding box will be highlighted.
3. Press the **Delete** or **Backspace** key on your keyboard. LandingLens automatically removes the label.

<video />

(This video has no sound.)

## Resize Bounding Boxes

You can adjust the size of a bounding box to more accurately identify the object of interest. Remember you want to draw bounding boxes as close to the objects of interest as possible.

To resize a bounding box:

1. Open the image that has the label you want to resize.
2. Move your cursor to the corner of the bounding box that you want to adjust. Your cursor will display a double-sided arrow cursor (resize cursor).
3. Click and drag the bounding box until you see the results you want.

<video />

(This video has no sound.)


# October 2022 Release Notes
Source: https://landinglens.docs.landing.ai/october-2022-release-notes



## What's New

* You used to have to install .NET runtime to use LandingEdge. We threw this requirement out the window, so enjoy the extra \~50MB of space!
* Have internet or network issues when trying to use LandingEdge? Well, then, this improvement is for you! We've removed the upload queue size limitation and added a retry mechanism for deployment. (To see this improvement in action, please uninstall and reinstall LandingEdge. Uploads may take a bit longer, but this is normal! Just keep the Inspection Point running for the uploads to complete.)
* Your eyes are not deceiving you—we've released a brand new [login page](https://support-landingai.document360.io/v1/docs/landinglens-login)! Plus, you can now quickly sign in with your Google account!
  <img alt="Login" />
* You asked, and we listened! You can now use your webcam to upload images to a LandingLens Project. But we didn't stop there! You can also run inference on images from your webcam with the Run Live feature.
  <img alt="Upload Images from Webcam" />

## Bug Fixes

* Fixed: Bounding boxes used to move around on their own when running inference on a static device. We decided find-the-bounding-box wasn't so fun, so we fixed this.
* Fixed: The user interface was stubborn and wouldn't listen when you changed the browser window size. Don't worry! We had a long talk with the user interface, so it should now respond to any browser window size.
* Fixed: The filters used to disappear on the Historical Data tab. They aren't great at hide-and-seek because we found them pretty quickly and moved them back, so you can now search for any inference image.
* Fixed: Some cURL request endpoints went on vacation, but we've told them to come back. They're now working hard on the Live Prediction tab.
* Fixed: LandingEdge used to check for a valid license when capturing images without a Model. However, this isn't necessary, so we removed this validation.
* Fixed: Before, Anomaly Detection Models weren't working with Run Live or LandingEdge. Not to worry, we fixed this!
* Fixed: To save you time, we fixed LandingEdge, so the application now bundles all Nvidia GPU-related CUDA and cuDNN libraries.


# Organizations
Source: https://landinglens.docs.landing.ai/organizations



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✖</span></td>
    </tr>
  </tbody>
</table>

An **organization** (sometimes called **org** for short) is a silo of data for your company's instance of LandingLens.

* Each LandingLens project and model will be saved to an organization.
* Each email address associated with a LandingLens account will be tied to an organization.
* One email address can be associated with one or more organizations.

<Info>If your organization use [Enterprise SSO](./landinglens-login), then all users within that organization must use this login type.</Info>

## Create a New Organization

<Info>If your company already has an organization, creating a new one will automatically create a Free organization.</Info>

<Info>You can have multiple organizations in your instance of LandingLens. However, you can only have one Enterprise organization.</Info>

To create an organization:

1. Click the **User Menu** and select **Switch Organization** .
   <img alt="new_org_1" />
2. Click **Create Organization**.
   <img alt="new_org_2" />
3. Follow the on-screen instructions to finish creating the new organization.

## Switch Organizations

The organization you are logged in to displays in the upper-right corner of LandingLens.

<img alt="Organization Name" />

1. Click the **User Menu** and select **Switch Organization** .
   <img alt="Switch Organization" />
2. Click the organization you want to switch to.
   <img alt="Switch Organization" />

## Join an Organization

Users who are invited to LandingLens will receive an email with a link to join the platform. After the user creates their account, they will see the organization they are invited to. Users should click the **Join** button to accept their invitation to the platform.

<img alt="Join Organization" />


# Manage Project Access
Source: https://landinglens.docs.landing.ai/override-project-access



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✖</span></td>
    </tr>
  </tbody>
</table>

Organizations on the **Enterprise** plan can manage project access from the **Project Access** page.

Members with the [Owner](./members) role can open the Project Access page to view and manage access to all projects in the organization, including private projects.

This allows Owners to have full visibility into every project, supporting better governance, oversight, and coordination. For example, if a project Owner of a private project leaves the organization, an organization Owner can reassign the project to a different member to ensure continuity.

For more information about managing project permissions and roles, go to [Public and Private Projects](./public-and-private-projects).

## Open the Project Access Page

Only Owners can see the Project Access page. To open the Project Access page:

1. Click the **User Menu** and select **Project Access**.
   <img alt="Project Access" />
2. A list of all projects displays.
   <img alt="Project Access" />

## Change Project Ownership

Owners can change the ownership of all projects, including private projects, in the Project Access page. To change project ownership:

1. Click the **User Menu** and select **Project Access**.
2. Click the **Actions** button next to the project you want to edit.
   <img alt="Change Ownership" />
3. Click **Change Ownership**.
4. Select the user you want to transfer project owernship to.
5. Click **Transfer**.
   <img alt="Change Ownership" />

## Manage Project Access

Owners can manage project access and members for all projects, including private projects, in the Project Access page. To manage project access:

1. Click the **User Menu** and select **Project Access**.
2. Click the **Actions** button next to the project you want to edit.
   <img alt="Change Ownership" />
3. Click **Manage Access**.
4. The Owner can now manage project access, which includes: adding and removing members, changing member access, inviting members, and making the project public or private. For more information about managing project access, go to [Public and Private Projects](./public-and-private-projects).
   <img alt="Change Ownership" />

## Delete Projects from Project Access Page

Owners can delete projects,including private projects, in the Project Access page. For more details about the impacts of deleting projects, go to [Delete Projects](./delete-projects).

To delete projects:

1. Click the **User Menu** and select **Project Access**.
2. Click the **Actions** button next to the project you want to edit.
   <img alt="Change Ownership" />
3. Click **Delete Project**.
4. Follow the on-screen instructions to finish deleting the project.


# Passwords
Source: https://landinglens.docs.landing.ai/passwords



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✖</span></td>
    </tr>
  </tbody>
</table>

## Password Requirements

* Passwords must be at least eight characters long
* Passwords must have at least one of the following:- Number
* Uppercase letter
* Lowercase letter
* Special character, like `!@#$%^&&*()-:;|<>`,

## Reset Your Password

You can reset your password at any time. This is useful if:

* You forgot your password
* Your organization requires that you reset your password after a certain period of time

To reset your password:

1. Log out of LandingLens (if you're not already) and go to the LandingLens login page for your organization.
   <img alt="LandingLens Homepage" />
2. Click **Forgot Password**.
   <img alt="Forgot Password" />
   <img alt="Forgot Password" />
3. Enter your email address that is linked to your account in the **Email Address** field.
4. Click **Send Verification Code**. These events occur:
   * Your browser window loads to a new page which will allow you to reset your password. Do NOT close this window.
   * An email with a verification code is sent to you.
     <img alt="Send Code" />
5. Open the email sent to you and copy the **Verification Code**.
   <img alt="Verification Code" />
6. Paste the **Verification Code** into the **Verification Code** field.
7. Enter your new password in the **Password** field. Remember to follow the [password requirements](./passwords#password-requirements).
8. Click **Reset Password**. Your password is reset.
   <img alt="Reset Password" />


# Performance Report
Source: https://landinglens.docs.landing.ai/performance-report



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

Clicking an evaluation set score on the **Models** page opens the **Performance Report** tab (you can also click a model on the **Models** page and then select this tab).

This report shows how the model performed on the selected *evaluation set* (and not for the entire dataset). You can select different sets from the **Evaluation Set** drop-down menu.

<img alt="PerformanceReport_Feb_2025" />

## Analyze Model Performance

Watch the following video to learn how to use the Performance Report and related tools to analyze and improve model performance.

<iframe title="YouTube video player" />

## Adjust Threshold

You can see how the model performs on the evaluation set with different **Confidence Thresholds** (for Object Detection and Segmentation) or **Anomaly Thresholds** (for Anomaly Detection). To do this:

1. Open the Performance Report.
2. Click **Adjust**.
   <img alt="PerformanceReport_ConfThresh_Adjust_1_Feb_2025" />
3. Change the threshold by using the slider or by entering a value in the text box.
4. If you want to see a full performance report for the selected threshold, click **Generate a New Report**.
   <img alt="PerformanceReport_ConfThresh_Adjust_2" />
5. LandingLens creates a new performance report for the selected threshold. (This is a temporary report. If you close and then later reopen the report, the data will be for the original threshold.)
   <img alt="PerformanceReport_ConfThresh_Adjust_3_Feb_2025" />

## Overall Score for the Evaluation Set

The Performance Report includes a score for the *evaluation set* (and not for the entire dataset). The type of score depends on the project type:

* [Object Detection, Classification, Anomaly Detection: F1 Score](./performance-report#object-detection-classification-anomaly-detection-f1-score)
* [Segmentation: Intersection Over Union (IoU)](./performance-report#segmentation-intersection-over-union-iou)

### Object Detection, Classification, Anomaly Detection: F1 Score

The Performance Report includes the F1 score for Object Detection, Classification, and Anomaly Detection projects.

<img alt="PerformanceReport_F1" />

For **Object Detection**, the F1 score combines precision and recall into a single score, creating a unified measure that assesses the model’s effectiveness in minimizing false positives and false negatives. A higher F1 score indicates the model is balancing the two factors well. LandingLens uses micro-averaging to calculate the F1 score.

For **Classification** and **Anomaly Detection**, the F1, Precision, and Recall scores are identical. This is because these models have only two prediction outcomes: "Correct" and "Misclassified". Therefore, the F1, Precision, and Recall scores for these models are all calculated using this algorithm:

$$
\frac{Corrects}{Misclassifieds}
$$

### Segmentation: Intersection Over Union (IoU)

The Performance Report includes the Intersection over Union (IoU) score for Segmentation projects.

<img alt="PerformanceReport_IOU" />

Intersection over Union (IoU) is used to measure the accuracy of the model by measuring the overlap between the predicted and actual masks in an image. A higher IoU indicates better agreement between the ground truth and predicted mask. LandingLens does not include the implicit background and micro-averaging in the calculation of the IoU.

## Precision Score for Evaluation Set

The Performance Report includes the Precision score for the evaluation set (and not for the entire dataset).

<img alt="PerformanceReport_Precision" />

**Precision** is the model’s ability to be accurate when it says something is true. Precision answers the natural language question, “When the model makes a prediction, how often is it correct?” This metric shows how accurate the model predictions are. The higher the Precision score, the more accurate the predictions are.

For **Object Detection** and **Segmentation**, Precision is calculated using this algorithm:

$$
Precision = \frac{TruePositives}{TruePositives + FalsePositives}
$$

For **Classification** and **Anomaly Detection**, the F1, Precision, and Recall scores are identical. This is because these models have only two prediction outcomes: "Correct" and "Misclassified". Therefore, the F1, Precision, and Recall scores for these models are all calculated using this algorithm:

$$
\frac{Corrects}{Misclassifieds}
$$

## Recall Score for Evaluation Set

The Performance Report includes the Recall score for the evaluation set (and not for the entire dataset).

<img alt="PerformanceReport_Recall" />

**Recall** is the model’s ability to find all objects of interest. Recall answers the natural language question, “Of all the labels (ground truths) in the dataset, what percent of them are found by the model?” It conveys how accurately the model can correctly identify all the actual positive instances in the dataset. The higher the Recall score, the lower the chance the model will have a false negative.

For **Object Detection** and **Segmentation**, Recall is calculated using this algorithm:

$$
Recall = \frac{TruePositives}{TruePositives + FalseNegatives}
$$

For **Classification** and **Anomaly Detection**, the F1, Precision, and Recall scores are identical. This is because these models have only two prediction outcomes: "Correct" and "Misclassified". Therefore, the F1, Precision, and Recall scores for these models are all calculated using this algorithm:

$$
\frac{Corrects}{Misclassifieds}
$$

## Download CSV of Evaluation Set

For Object Detection and Classification projects, click **Download CSV** to download a CSV of information about the images in the evaluation set. The CSV includes several data points for each image, including the labels ("ground truth") and model's predictions.

<img alt="PerformanceReport_Download_CSV" />

### **CSV Data for Evaluation Set**

The CSV includes the information described in the following table.

| Item             | Description                                                                                                                                                                                                                                                                   | Example                                                                            |
| ---------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------- |
| Image ID         | Unique ID assigned to the image.                                                                                                                                                                                                                                              | 30243316                                                                           |
| Image Name       | The file name of the image uploaded to LandingLens.                                                                                                                                                                                                                           | sample\_003.jpg                                                                    |
| Image Path       | The URL of where the image is stored.                                                                                                                                                                                                                                         | s3://path/123/abc.jpg                                                              |
| Model ID         | Unique ID assigned to the model.                                                                                                                                                                                                                                              | a3c5e461-0786-4b17-b0a8-9a4bfb8c1460                                               |
| Model Name       | The name of the model in LandingLens.                                                                                                                                                                                                                                         | Model-06-04-2024\_5                                                                |
| GT\_Class        | The classes you assigned to the image (ground truth or “GT”) .<br /><br />For Object Detection, this also includes the number of objects you labeled.                                                                                                                         | `{"Scratch":3}`                                                                    |
| PRED\_Class      | The classes the model predicted.<br /><br />For Object Detection, this also includes the number of objects predicted.<br /><br />If the model didn't predict any objects, the value is `{"null":1}`.                                                                          | `{" Scratch":2}`                                                                   |
| Model\_Correct   | If the model's prediction matched the original label (ground truth or “GT”), the value is `TRUE`.<br /><br />If the model's prediction didn't match the original label (ground truth or “GT”), the value is **FALSE**.<br /><br />Only applicable to Classification projects. | `TRUE`                                                                             |
| PRED\_Confidence | The model's confidence score for its prediction.<br /><br />Only applicable to Classification projects.                                                                                                                                                                       | 0.9987245                                                                          |
| GT-PRED JSON     | The JSON output comparing the original labels (ground truth or "GT") to the model's predictions. For more information, go to [JSON Output](./json-responses).                                                                                                                 | `{"gtDefectName":"No Fire","predDefectName":"No Fire","predConfidence":0.9684047}` |

<Info>This CSV covers the selected evaluation set. If you want per-image predictions for every split in the model's dataset, or you want to download the data with the API, go to [Download CSV of Model Predictions](./model-settings#download-csv-of-model-predictions).</Info>

## Confusion Matrix

The Performance Report includes a Confusion Matrix that counts ground truth labels versus model predictions. The confusion matrix shown here is for the *selected evaluation set*.

The y-axis represents each ground truth label. The x-axis represents each possible model prediction.

Each cell shows the count of instances that correspond to particular ground truth class-predicted class pair. For example, in the image below, the model correctly predicted the class "Wheat" 6 times and misclassified it 2 times.

<img alt="confusionMatrix_Jan_2025" />

### Precision Score for Class

The Precision score for each class is listed along the x-axis. Precision answers the natural language question, “When the model predicts Class A, how often is it correct?”

The Precision score for a class is the percentage of instances that the model correctly predicted the class out of all instances that the model predicted the class, and is calculated using this equation:

$$
Precision_A = \frac{TruePositives_A}{TruePositives_A + FalsePositives_A}
$$

For example, let’s calculate the Precision score for the Wheat class in the image below. The model predicts Wheat 7 times. Of those, 6 are correct (True Positives) and 1 is incorrect (False Positives). When we plug those numbers into the Precision equation, we see that the Precision for this class is 85.7%.

$$
= \displaystyle\frac{6}{6 + 1}
$$

$$
= 85.7\%
$$

<img alt="Precision Score for Wheat" />

### Recall Score for Class

The Recall score for each class is listed along the y-axis. Recall answers the natural language question, “Of all the Class As in the dataset, what percent of them are found by the model?”

The Recall score for a class is the percentage of instances that the model correctly predicted the class out of all actual instances of the class, and is calculated using this equation:

$$
Recall_A = \frac{TruePositives_A}{TruePositives_A + FalseNegatives_A}
$$

For example, let’s calculate the Recall score for the Wheat class in the image below. The dataset has 8 instances of Wheat. The model predicts 6 instances correctly (True Positives) and 2 instances incorrectly (False Negatives). When we plug those numbers into the Recall equation, we see that the Recall for this class is 75.0%.

$$
= \displaystyle\frac{6}{6 + 2}
$$

$$
= 75.0\%
$$

<img alt="Recall Score for Wheat" />

### Use Colors to Help Interpret Performance

Each cell has a color that can quickly help you identify correct classifications and errors. Darker colors indicate a higher number, and lighter colors indicate a lower number.

For example, if the model correctly predicts all instances, only the cells on the diagonal will be blue and have non-zero values. See the following image as an example.

<img alt="All Correct Predictions" />

If any off-diagonal cells contain values, start by looking for the darker colors to understand where the model is making errors. For example, let’s say you want to evaluate performance for the Rice class using the confusion matrix below. The model correctly predicted 1 instance and misclassified 3 instances. Consider looking at the instances that were misclassified as Corn first, since that cell is darker (and has a higher number) than the Wheat cell.

<img alt="Some Incorrect Predictions" />

### Click a Cell for Detailed Information

Click a cell in the confusion matrix to see detailed information for that ground truth / prediction pairing. For example, click the Wheat/Corn cell in the image below to see the image that was labeled as Wheat but predicted as Corn.

The table on the **left** shows the ground truth / prediction pairings for *all image*s in the evaluation set. The section on the **right** shows the images that represent the cell you clicked.

<img alt="confusionMatrix_pairingResults_Jan_2025" />

## Analyze All Images

Click **Analyze All Images** to see all images with their ground truth labels and predictions. Click an image to see a larger version.

For **Object Detection** and **Segmentation**, LandingLens shows a side-by-side comparison of the ground truth labels and predictions on each image in the dataset.

<img alt="AnalyzeAllImages_OD" />

For **Classification** and **Anomaly Detection**, LandingLens shows each image, the ground truth class, and whether the model predicted the class correctly (green check mark) or not (red "x").

<img alt="AnalyzeAllImages_CLASS" />


# Plans
Source: https://landinglens.docs.landing.ai/plans



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✖</span></td>
    </tr>
  </tbody>
</table>

## Get LandingLens

Sign up for LandingLens for free [here](https://app.landing.ai/signup)!

<Info>We recommend using LandingLens in a Chrome browser.</Info>

## LandingLens Plans

&#x20;offers these plans to meet your computer vision needs: **Free** and **Enterprise**. Get detailed information on our [Pricing](https://landing.ai/pricing/) page.

| Feature                                 | Free                                 | Enterprise                                                    |
| --------------------------------------- | ------------------------------------ | ------------------------------------------------------------- |
| **General**                             |                                      |                                                               |
| Cost                                    | \$0                                  | Contact [sales](https://landing.ai/contact-sales) for pricing |
| Credits                                 | 1,000 per month                      | Custom                                                        |
| Credit Overages                         | Not supported                        | Custom                                                        |
| Create Organizations                    | Unlimited                            | Unlimited<br />                                               |
| Invite Users<br />                      | 3                                    | Custom                                                        |
| Create Projects                         | Unlimited<br />                      | Unlimited<br />                                               |
| Role/Access Control                     | ✓<br />                              | ✓<br />                                                       |
| **Data Management**                     |                                      |                                                               |
| Unlimited Projects                      | ✓<br />                              | ✓<br />                                                       |
| Unlimited Classes                       | ✓<br />                              | ✓<br />                                                       |
| Up to 10k images per project<br />      | ✓<br />                              | ✓<br />                                                       |
| Image Annotation<br />                  | ✓<br />                              | ✓<br />                                                       |
| Import Labeled Images<br />             | ✓<br />                              | ✓<br />                                                       |
| Agreement-Based Labeling<br />          | ✓<br />                              | ✓<br />                                                       |
| Meta Data Management/Tags<br />         | ✓<br />                              | ✓<br />                                                       |
| **Model Training**                      |                                      |                                                               |
| Model Training<br />                    | ✓<br />                              | ✓<br />                                                       |
| Snapshot (Versioning)<br />             | Unlimited                            | Unlimited<br />                                               |
| Visual Prompting<br />                  | ✓<br />                              | ✓<br />                                                       |
| Advanced Training<br />                 | ✓<br />                              | ✓<br />                                                       |
| **Model Deployment**                    |                                      |                                                               |
| LandingEdge<br />                       | ✓<br />                              | ✓<br />                                                       |
| Docker App<br />                        | ✓<br />                              | ✓<br />                                                       |
| Unlimited Cloud Model Deployments<br /> | ✓<br />                              | ✓<br />                                                       |
| Active Project/Download Model<br />     | 1 Download - Noncommercial Use<br /> | Starting at 5<br />                                           |
| **Security & Access**                   |                                      |                                                               |
| Private Projects<br />                  | ✓<br />                              | ✓<br />                                                       |
| SAML SSO<br />                          | -<br />                              | ✓<br />                                                       |
| **Support**                             |                                      |                                                               |
| Community Support<br />                 | ✓<br />                              | ✓<br />                                                       |
| In-Product Support<br />                | ✓<br />                              | ✓<br />                                                       |
| Customer Success<br />                  | -<br />                              | ✓<br />                                                       |

## Sign Up for a LandingLens Plan

Sign up for LandingLens [here](https://app.landing.ai/signup)!

All plans start as the Free plan. You can [upgrade](./plans#upgrade-to-the-enterprise-plan) your plan at any time.

## Credits

Credits are a form of currency on the LandingLens platform. You spend credits when you perform these actions:

* **Train models**: “Teach” models what they should detect.
* **Run inference**: Have the model detect what it was "taught" to look for in new images.

Anyone in your organization can use the credits. You can find more information about your organization's credit balance and usage on the **Plan and Billing** and **Usage** pages.

<img alt="plan_billing_Dec_2024" />

### What can I spend my credits on?

Credits are used for training models or making predictions. The number of credits used depends on whether you're using [Fast Training](./train-models) (the default training method) or [Custom Training](./custom-training):

|                             | Fast Training Cost | Custom Training Cost                          |
| --------------------------- | ------------------ | --------------------------------------------- |
| Include 1 image in training | 1 credit           | Depends on project type and training settings |
| Run inference on 1 image    | 1 credit           | Depends on project type and training settings |

For detailed information about how credits are calculated for Custom Training, go [here](./custom-training).

### Credit Usage Example

Here's an example of how you can "spend" 5,000 credits:

| Action                                                                                                                                                                                     | Credits Used | Credits Left |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------ | ------------ |
| Use Fast Training to train a model with 200 images.                                                                                                                                        | 200          | 4,800        |
| You want to improve model performance so you update labels. Then you run Fast Training with the 200 images again.                                                                          | 200          | 4,600        |
| You run inference on 10 images to see how the model performs on images it hasn't seen before. Since the model was created using Fast Training, each inference (prediction) costs 1 credit. | 10           | 4,590        |
| Based on how the model performed on the new images, you update the labels. Then you run Fast Training with the 200 images again.                                                           | 200          | 4,390        |
| You run inference on 10 images again to test the model.                                                                                                                                    | 10           | 4,380        |
| You are happy with the model performance. You can now deploy the model to a production environment and use the rest of the credits to run inference.                                       | 4380         | 0            |

### Can I go over my allotted credits?

If you're on the **Free** plan, your organization is allotted 1,000 credits per billing cycle. More credits cannot be added.

If you're on the **Enterprise** plan, contact your account team or [support@landing.ai](mailto:support@landing.ai) for information about how credits are managed.

### Do credits roll over at the end of the billing cycle?

For Free plans, credits do not roll over. Your allotted credits reset each month.

If you're on the **Enterprise** plan, contact your account team or [support@landing.ai](mailto:support@landing.ai) for information about how credits are managed.

### Who can use credits?

All credits are placed into your organization's "bank". Anyone in your LandingLens organization can use those credits.

### If I spent credits on a project and delete that project, will those credits be refunded?

No. Any credits that have been spent cannot be refunded.

### Predict at Upload

The **Predict at Upload** setting impacts credit usage. If **Predict at Upload** is enabled and you upload a new image to a project that already has a trained model, the model runs inference on that image. Running inference on an image consumes credits. By default, the **Predict at Upload** setting is disabled.

To enable or disable the **Predict at Upload** setting, go to the **Plan and Billing** page.

<img alt="PredictAtUpload_June2024" />

## Upgrade to the Enterprise Plan

If you'd like to upgrade to the Enterprise plan, or you're not sure which features you need for your use case, contact our [Sales team](mailto:sales@landing.ai).

## Downgrade or Cancel Your Plan

If you want to downgrade or cancel an Enterprise plan, contact our [Sales team](mailto:sales@landing.ai).


# Pre Processing
Source: https://landinglens.docs.landing.ai/pre-processing



This article describes the pre-processing APIs to convert gray to RGB.

## Folder Structure

\| .<br />├── custom<br />│ ├── **init**.py<br />│ ├── custom\_gray2rgb.py<br />├── train.yaml<br />└── transforms.yaml |
\| --- |## Gray to RGB Class

| import cv2from avi\_transforms import DataItemclass Gray2RGB:<br /> """Test transform to convert Gray to RGB""" def **init**(self, defect\_map, \*\*kwargs):<br /> *# Example to show passing arguments to custom transform*<br /> print(defect\_map) def **call**(self, inputs: DataItem) -> DataItem:<br /> image = inputs.image<br /> if image.ndim == 3:<br /> image = image\[..., 0]<br /> rgb = cv2.cvtColor(image, cv2.COLOR\_GRAY2RGB)<br /> return DataItem(image=rgb) |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

## Use Gray to RGB in transforms.yaml

| train:<br /> - GaussianBlur:<br /> lower\_limit: 5<br /> upper\_limit: 9<br /> p: 0.8<br /> - VerticalFlip:<br /> p: 0.2<br /> - CustomTransform:<br /> transform: custom.custom\_gray2rgb.Gray2RGB<br /> params:<br /> defect\_map:<br /> 0: ok<br /> 1: ng<br /> p: 1.0<br />valid: |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |


# Project Types
Source: https://landinglens.docs.landing.ai/project-types



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span> (see exceptions below)</td>
    </tr>
  </tbody>
</table>

<iframe title="YouTube video player" />

LandingLens offers these project types:

* Object Detection
* Classification
* Segmentation
* Anomaly Detection
* &#x20;(not available in )

<img alt="ProjectTypes" />

## Object Detection

Use to identify one or more objects in an image. Object Detection trains based on the labeled pixels (pixels inside the bounding box).

For more information, go to [Object Detection](./object-detection).

## Classification

Use to categorize (or "classify") the content of an image. Classification identifies the image as a whole. Classification trains based on all pixels in an image.

For more information, go to [Classification](./classification).

## Segmentation

Use to specify exact pixels to identify one or more regions within an image.

For more information, go to [Segmentation](./segmentation).

## Anomaly Detection

Use to identify deviations from the norm, especially when you have few or no images of "abnormal" cases.

For more information, go to [Anomaly Detection](./anomaly-detection).

## Visual Prompting

Use to identify objects or areas in an image. You only need to label a few small areas for the model to detect the whole object or area.

For more information, go to [Visual Prompting](./visual-prompting).

<Info> is not available in .</Info>

<Info>Visual Prompting is in Beta. It might not function as well as our other production-ready features.</Info>

## When to Use Each Project Type

Each Project Type is also designed for different use cases:

| Project Type                                                                                                                             | When to Use                                                                                                                                                                                                                             | Examples                                                                                                                                                                                                                    |
| ---------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Object Detection                                                                                                                         | <ul><li>You want to identify multiple objects in an image.</li><li>You want to identify one object in an image.</li></ul>                                                                                                               | Identify multiple objects in an image.<ul><li>Scratches and missing parts on a laptop</li><li>Apples and bananas</li></ul>Identify one object in an image.<ul><li>Deer</li><li>Person</li><li>License plate frame</li></ul> |
| Classification                                                                                                                           | <ul><li>You want to identify all the content within an image.</li><li>You want to distinguish one object type from another.</li></ul>                                                                                                   | Identify all content within an image.<ul><li>Image of a city</li><li>Image of a basketball</li></ul>Distinguish one object type from another. <ul><li>Screws vs. nails</li><li>Cats vs. dogs</li></ul>                      |
| Segmentation                                                                                                                             | <ul><li>You need to be precise.</li><li>You want to identify one or more regions in an image.</li></ul>                                                                                                                                 | <ul><li>Identify cracks on computer monitors </li></ul>                                                                                                                                                                     |
| Anomaly Detection                                                                                                                        | <ul><li>You want to identify deviations from the norm.</li><li>You have few or no images of "abnormal" cases.</li></ul>                                                                                                                 | <ul><li>Identify defects</li><li>Identify missing components on a product</li><li>Identify missing parts from a kit</li><li>Identifiy abnormalities in medical images</li></ul>                                             |
| <ul><li>You want to create a model quickly. </li><li>You want to identify all regions in an image.</li><li>You are not using .</li></ul> | Identify objects with distinct textures.<ul><li>Animals</li><li>Sand vs. rocks on a beach</li></ul>Identify objects that have irregular shapes.<ul><li>Regions of forests in satellite imagery</li><li>Scratches on a product</li></ul> |                                                                                                                                                                                                                             |


# Projects
Source: https://landinglens.docs.landing.ai/projects-overview



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

In LandingLens, you can create a project to help you keep your work in one place. Let’s say you are in charge of inspecting items at your organization, and an image is taken of each item. You need to determine whether that item has a defect.

Projects are used to investigate a specific solution or use case. Here are some examples of when to create a project:

* You want to identify foreign objects in food.
* You want to identify scratches on phones.
* You want to identify cracks and chips on slabs of cement.
* You want to identify missing pieces on a circuit board.
* You want to identify screws and nails.


# Public and Private Projects
Source: https://landinglens.docs.landing.ai/public-and-private-projects



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

When you create a project, it is public by default. This means that everyone in your LandingLens organization can access it. You can make the project private at any time, and invite only specific members to access the project.

Regardless of whether your project is public or private, no one outside of your LandingLens organization can access your project.

<Info>If you're using , a "member" is considered to be a user that has logged in to your instance of .</Info>

## Project Permissions

When you invite members to your project, you can choose how they can participate in your project. This is managed with Permissions. These are the types of Permissions:

* **Upload Data**: Users can upload images.
* **Train Model**: Users can train the model.
* **Deploy Model**: Users can deploy the model.
* **Direct Label**: Users can label images.

## Limit Project Access to Specific Members (Make Private)

<iframe title="YouTube video player" />

1. Open the project.
2. Click **Settings** in the left sidebar.
3. Click **Edit** on the **Permission** tab.
   <img alt="InviteUsers_1(2)" />
4. Select **Only invited members can access the project**.
   <img alt="InviteUsers_2" />
5. Click **Invite**.
6. Search by name to narrow down the list of users.
7. Select the members you want to invite.
8. Select the [Project Permissions](#project-permissions) you want to give the member.
9. Click **Add Members to Projects**. An email is sent to the users, inviting them to your project.
   <img alt="InviteUsers_4(1)" />

### Member Actions on the Permission Tab

The Permission tab on the Settings page allows you to manage member access to projects. These are the actions you can perform:

* **Manage Permissions**: Edit the Permissions of the member. This option is only available for members that have the "Standard" role.
* **Change Role**: Projects have three types of Roles—Owner, Labeler, and Standard.
  * **Owners** are generally the creators of projects. They can perform any action on the project.
  * **Labelers** can only label images.
  * **Standard** members can have a mix of access to a project. Their access is defined with [Permissions](#project-permissions).
* **Transfer Ownership**: Make the selected user Owner of the project.
* **Remove**: Remove the member from the project.
  <img alt="UserActions" />

<Info>After making an edit, click **Done** to save your updates.</Info>

## Grant Project Access to All Members in Your Organization (Make Public)

If you've made a project private, you can make it public again. To do this:

1. Open the project.
2. Click **Settings** in the left sidebar.
3. Click **Edit** on the **Permission** tab.
   <img alt="MakePublic_1" />
4. Select **Anyone in the organization can access the project**.
   <img alt="MakePublic_2" />
5. Confirm that you want to make the project public.
   <img alt="MakePublic_3" />


# Python Tutorial: Detect Suits in Playing Cards
Source: https://landinglens.docs.landing.ai/python-tutorial



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✖</span></td>
    </tr>
  </tbody>
</table>

<iframe title="YouTube video player" />

&#x20;offers code samples in [Python](https://github.com/landing-ai/landingai-python) and [JavaScript](https://github.com/landing-ai/landingai-js) libraries to help you learn how to effectively deploy computer vision models you’ve built in LandingLens.

This tutorial explains how to use the [Detect Suits in Poker Cards](https://github.com/landing-ai/landingai-python/blob/main/examples/webcam-collab-notebook/webcam-collab-notebook.ipynb) example in the Python library to run an application that detects suits in playing cards. In this tutorial, you will use a web camera to take images of playing cards. An Object Detection model developed in LandingLens (and hosted by ) will then run inference on your images.

This example is run in a Jupyter Notebook, but you can use any application that is compatible with Jupyter Notebooks.

## Requirements

* Python (install for free [here](https://www.python.org/downloads/))
* Jupyter Notebook (install for free [here](https://jupyter.org/install))
* Playing cards
* Webcam

## Step 1: Clone the Repository

Clone the  Python repository from GitHub to your computer. This will allow you to later open the [webcam-collab-notebook](https://github.com/landing-ai/landingai-python/blob/main/examples/webcam-collab-notebook/webcam-collab-notebook.ipynb) Jupyter Notebook, which is in the repository.

To clone the repository, run the following command:

```bash theme={null}
git clone https://github.com/landing-ai/landingai-python.git
```

<Info>You can use other methods to clone repositories. For more information, check out the [GitHub documentation](https://docs.github.com/en/repositories/creating-and-managing-repositories/cloning-a-repository).</Info>

## Step 2: Open the Jupyter Notebook

Open Jupyter Notebook by running this command in your terminal:

```bash theme={null}
jupyter notebook
```

In Jupyter Notebook, open the `landingai-python` repository you cloned.

Navigate to and open this file: `landingai-python/examples/webcam-collab-notebook/webcam-collab-notebook.ipynb`.

<img alt="cards_tutorial_1" />

The notebook opens in a new tab or window.

<img alt="cards_tutorial_2" />

## Step 3: Start Running the Application

The notebook consists of a series of code cells. Run each code cell, one at a time.

An asterisk (\*) displays in the pair of brackets next to a code cell while that code executes. When the code has run, the asterisk disappears.

<Info>Not too familiar with Jupyter Notebook? To run a code cell, click the **Run** button in the toolbar, or press **Shift**+**Enter**. You need to do this for each cell!</Info>

## Step 4: Take a Photo with Your Webcam

When you run the **Acquire Image from Camera** code cell, the application turns on your webcam. Hold a playing card up to the webcam and press **Spacebar** to take a photo.

Your webcam turns off, and the image displays below the code cell.

<img alt="cards_tutorial_3" />

<Info>Don’t like the photo? You can replace it by running the **Acquire Image from Camera** code cell again.</Info>

## Step 5: Run the Model and See the Predictions

Continue running the code cells.

Running the **Run the Object Detection Model on LandingLens Cloud** code cell initiates the model in LandingLens to run inference on your image.

Then, when you run the **Visualize Results** code cell, an image displays below the cell. This is your original image, with the predictions from the LandingLens model overlaid on top. The prediction includes the bounding box, the name (Class) of the object detected, and the Confidence Score of the prediction.

For example, in the screenshot below, the model identified that the card has several Diamonds.

<img alt="cards_tutorial_4" />

## Step 6: Count How Many Objects Were Detected

Run the next code cell, which is **Process Results to Count the Number of Suits**. When you run this code, the application counts how many objects were detected that had a confidence score higher than 50%. The count displays below the code cell.

For example, in the screenshot below, the application counted four Diamonds that met the threshold criteria.

<img alt="cards_tutorial_5" />

## Step 7: Make Your Own Application

Congrats! You have now successfully run a LandingLens model and made predictions! You can now customize the code cells to create your own application!


# Rename Models
Source: https://landinglens.docs.landing.ai/rename-models



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

## Default Model Name

When you train a model, LandingLens now automatically saves and names it. This ensures that you can access all versions of your data in the [snapshots dashboard](./dataset-snapshots). Automatically saving the models also prevents models from being accidentally overwritten.

The default model naming convention is **Model-mm-dd-yyyy\_n**, where **n** is the number of models in the project trained that day. For example, let’s say you train six models in a project on December 10, 2023. The default name of the sixth model will be **Model-12-10-2023\_6**.

You can rename a model at any time.

## Rename Models

You can rename models at any time. Model names can include letters, numbers, and special characters.

To rename a model:

1. Open the project.
2. Click the **Models** tab.
3. Click the model you want to rename.
   <img alt="modelRename_1" />
4. Click the **Edit** (pencil) icon next to the model name and enter a new name.
   <img alt="modelRename_2" />


# Run Inference with SQL Commands
Source: https://landinglens.docs.landing.ai/run-inference-with-sql-commands



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✖</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

<iframe title="YouTube video player" />

After deploying a model with [Cloud Deployment](./cloud-deployment), you can run inference using this function, where `APP_NAME` is the [name of your LandingLens instance](./app-name):

```bash theme={null}
APP_NAME.core.run_inference(file_path varchar, endpoint_id varchar)
```

Here is how you select the function:

```bash theme={null}
SELECT APP_NAME.core.run_inference(file_path varchar, endpoint_id varchar) as inference;
```

## Prerequisites

* You must be granted the [LLENS\_PUBLIC application role](./llens-public-application-role) to run this function.
* The inference function requires the name of your LandingLens instance (`APP_NAME`). To locate the name, go to [Name of LandingLens Instance](./app-name).
* If running inference on images in Snowflake stages, you must first grant LandingLens access to the stage. To do this, go to [Grant LandingLens Access to Stages](./grant-landinglens-access-to-stages).

## Arguments

`file_path`

A VARCHAR string that defines the location of an image or set of images to run inference on. This can be:

* images in Snowflake, including images in tables
* publicly-available HTTP/HTTPS URLs, including publicly-available Amazon S3 URLs

`endpoint_id`

A VARCHAR string that defines the endpoint of a model deployed with Cloud Deployment. The `endpoint_id` displays on the Deploy page in LandingLens.

<img alt="sf_endpoint" />

## Run Inference on Multiple Images

To use the `run_inference` function to run inference on multiple images, the image filepaths must be in a table or table-like format. For example, you can use the [LIST](https://docs.snowflake.com/en/sql-reference/sql/list) command to list all files in a stage in a table-like format. You can then incorporate the LIST command results in the `run_inference` function.

For more information, see [this example](./run-inference-with-sql-commands#example-add-images-from-a-stage-to-a-table-and-run-inference).

## Inference Function Results

Running inference with the function returns prediction results in a [JSON format](./json-responses). This is the same format that is returned when running Cloud Deployment using any other method.

<img alt="sf_inference_url_results_json" />

The image and the prediction also display on the [Deploy](./historical-data) page in LandingLens (refresh the page in LandingLens to see the results).

<img alt="sf_inference_url_results_ll" />

## Locate the Function

LandingLens automatically generates the inference function that is populated with the name of your instance of LandingLens. You can get the function for your instance of LandingLens in Snowsight:

1. Open [Snowsight](https://app.snowflake.com/).
2. Go to **Data Products** > **Apps** > **LandingLens Visual AI Platform**.
3. Click **Launch App**.
   <img alt="locate_inference_statement_1" />
4. Click **APP\_WIZARD**.
5. Click **Settings**.
6. Expand the **Run inferences from SQL statement** section. The custom inference function for your instance of LandingLens displays.
   <img alt="locate_inference_statement_2" />

## Example: Run Inference on an Image Online

The function can run inference on publicly-available HTTP/HTTPS URLs. For example:

```bash theme={null}
SELECT LLENS_SNW_STAGING.core.run_inference('https://upload.wikimedia.org/wikipedia/commons/a/a1/Normal_posteroanterior_%28PA%29_chest_radiograph_%28X-ray%29.jpg', '2c77a3b4-e242-4509-985b-a6fea48a7c47') as inference;
```

## Example: Run Inference on an Image in Snowflake

Let's say you've installed the [Sample Dataset for LandingLens: LifeSciences Pneumonia](https://app.snowflake.com/marketplace/listing/GZTYZ12K65CA/) dataset from LandingAI. You can then run inference on images from that dataset. For example:

```bash theme={null}
SELECT LLENS_SNW_STAGING.core.run_inference('@llens_sample_ds_lifesciences.pneumonia.dataset/data/normal/IM-0001-0001.jpeg', 'e7fa760c-3472-42e0-b11c-ca219355cb19') as inference;
```

## Example: Run Inference on Images in a Snowflake Table

You can run inference on images in a Snowflake table. For example:

```bash theme={null}
SELECT
    LLENS_SNW_STAGING.core.run_inference(file_url_column, 'ac104c43-c6eb-4d1a-8a94-cfaf3dae8f70') as inference
FROM table_with_image_files
WHERE
    some_condition = true;
```

## Example: Add Images from a Stage to a Table and Run Inference

Let's say you want to run inference on multiple images in a Snowflake stage and save the results of the model's predictions. You can do this by running a series of SQL commands that:

1. create a table,
2. add the image file names to that table,
3. run inference, and
4. save the prediction results to that table.

To make this easier to understand, we've created a SQL script below that shows how to do this based on the [Sample Dataset for LandingLens: LifeSciences Pneumonia](https://app.snowflake.com/marketplace/listing/GZTYZ12K65CA/) dataset from LandingAI. The script explains how to run inference on the first 20 images in that dataset. Modify the script as needed for your use case.

### Prerequisites

Here are a set of prerequisites to consider when you're running the script on the sample dataset and when you're running it on your own dataset.

| Action                                | When Using LandingLens Sample Dataset                                                                                                                  | When Using Your Own Dataset                                                                                                                |
| ------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------ |
| Grant the LLENS\_PUBLIC role          | Grant yourself the [LLENS\_PUBLIC application role](./llens-public-application-role).                                                                  | Grant yourself the [LLENS\_PUBLIC application role](./llens-public-application-role).                                                      |
| Get LandingLens instance name         | Get the name of your instance of LandingLens. You will add this to the script.                                                                         | Get the name of your instance of LandingLens. You will add this to the script.                                                             |
| Install dataset                       | Install the [Sample Dataset for LandingLens: LifeSciences Pneumonia](https://app.snowflake.com/marketplace/listing/GZTYZ12K65CA/) dataset.<br /><br /> | N/A                                                                                                                                        |
| Grant LandingLens access to the stage | Grant LandingLens [access to the stage](./load-images-from-snowflake#grant-landinglens-access-to-a-stage) with the LandingLens dataset.                | Grant LandingLens [access to the stage](./grant-landinglens-access-to-stages) with your dataset.                                           |
| Train a model                         | [Train a model](./train-models) in LandingLens with the dataset.                                                                                       | [Train a model](./train-models) in LandingLens with the dataset.                                                                           |
| Deploy model and get endpoint ID      | Deploy the model with [Cloud Deployment](./cloud-deployment). Get the endpoint ID for the deployed model. You will add this to the script.             | Deploy the model with [Cloud Deployment](./cloud-deployment). Get the endpoint ID for the deployed model. You will add this to the script. |

### Sample SQL Script

You can copy and paste the following SQL script into a Worksheet in Snowsight. Update the placeholders that are called out in the commented parts of the code.

```bash theme={null}
-- Create a table. You will later use this to store the image filenames and inference results. 
-- This creates a table named file_inferences with two columns: filename and inference.
 CREATE TABLE file_inferences (
   filename varchar,
   inference variant
 );

-- Run the LIST command to return a list of all JPEG files in the sample dataset that are on the Snowflake stage.
LIST @LLENS_SAMPLE_DS_LIFESCIENCES.PNEUMONIA.DATASET PATTERN = '.*jpeg';

-- Run the following nested commands. 
-- These run inference on the images returned by the LIST command, add the image filenames to the filename column, and add the inference results to the inference column.
-- Replace "LANDINGLENS_SNOWFLAKE" with the name of your instance of LandingLens.
-- Replace "dda5e0f8-30ca-4ed5-abac-fb068af39379" with the endpoint ID of the model you deployed.
-- In the following code, "name" is the column from the LIST results that includes the image filenames.
-- The run_inference function requires a complete filepath, so you must concatenate the database and schema with the filename ('@LLENS_SAMPLE_DS_LIFESCIENCES.PNEUMONIA.' || "name"). 
-- Be sure to include the period at the end of the schema (PNEUMONIA.)
INSERT INTO file_inferences(filename, inference)
SELECT
   "name", LANDINGLENS_SNOWFLAKE.core.run_inference('@LLENS_SAMPLE_DS_LIFESCIENCES.PNEUMONIA.' || "name", 'dda5e0f8-30ca-4ed5-abac-fb068af39379') as inference
   FROM TABLE(RESULT_SCAN(LAST_QUERY_ID()))
   LIMIT 20;
```


# Sample Images
Source: https://landinglens.docs.landing.ai/sample-images



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✖</span></td>
    </tr>
  </tbody>
</table>

Don't have images to test? No problem! LandingLens offers pre-built models that you can play with and train. Check them out in the **Examples** section of LandingLens.

<img alt="Examples(1)" />

LandingLens also has sets of sample images that you can upload to new projects. When you create a project, click **Load Sample Data** and select a dataset.

<img alt="LoadSampleData_0" />


# Developer Tools
Source: https://landinglens.docs.landing.ai/sdk



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span> (see exceptions below)</td>
    </tr>
  </tbody>
</table>

&#x20;offers these developer tools to accelerate your deployment process and heighten your creativity

* [REST APIs](https://landing-ai.github.io/public-rest-api/fastapi/#/operations/create_image_v1_projects__project_id__images_post) (not supported for )
* [Python library](https://github.com/landing-ai/landingai-python)
* [JavaScript library](https://github.com/landing-ai/landingai-js) (not supported for )

The APIs and libraries include practical examples of how to run inference using models you've developed in LandingLens. The  libraries are available in [GitHub](https://github.com/landing-ai/).

<Info>We plan to add a C# library in the future.</Info>

## REST APIs

Use the [REST APIs](https://landing-ai.github.io/public-rest-api/fastapi/#/operations/create_image_v1_projects__project_id__images_post) to perform many tasks, including:

* Upload images to LandingLens.
* Create projects.
* Create classes.
* Assign split keys (Dev, Train, Test) to images.
* Train models.
* Deploy models.

<Info>The REST APIs don't support .</Info>

## Python Library

Use the [Python library](https://github.com/landing-ai/landingai-python) to:

* Upload labeled and unlabeled images to LandingLens.
* Capture images from various sources (video files, webcams, RTSP streams, etc.).
* Assign metadata values and split keys (Dev, Train, Test) to images.
* Get prediction results from your deployed model.
* Post-process your prediction results into other formats.
* Visualize your prediction results.
* Chain multiple model inference and post-processing operations together.

To learn more, check out these resources:

* [Python repository](https://github.com/landing-ai/landingai-python)
* [Python documentation](https://landing-ai.github.io/landingai-python)

### Using the Python Library with&#x20;

The Python library offers limited support for . The Python library can be used to [run inference](https://landing-ai.github.io/landingai-python/inferences/getting-started/) and perform [image operations](https://landing-ai.github.io/landingai-python/image-operations/) like cropping and resizing images. However, it doesn't support other functions for interacting with data on , like uploading images and assigning splits.

## JavaScript Library

Use the JavaScript library to:

* Get prediction results from your deployed model.
* Visualize your prediction results.
* Upload unlabeled images from your app.

To learn more, check out the [JavaScript repository](https://github.com/landing-ai/landingai-js).

<Info>The JavaScript library doesn't support .</Info>


# Segmentation
Source: https://landinglens.docs.landing.ai/segmentation



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span> (see exceptions below)</td>
    </tr>
  </tbody>
</table>

**Segmentation** is used to identify objects with great precision. This is done by using a "brush" or  to mark the exact location of an object you want your model to detect. This object type is commonly used for identifying irregular shapes.

Let’s say you want to identify cracks in cement. You could use Object Detection; however, bounding boxes would include too much background (or space that you do not want to include in your label). During model training, the model will look at every labeled pixel. If you include extra, unimportant pixels, the model might think these pixels are also important. Instead, use Segmentation so that you can precisely label the relevant areas. Compare the labeling options in the following images:

<img alt="Bounding Boxes for Segmentation" />

<img alt="Segmentation" />

## Labeling Tools for Segmentation

Segmentation offers the following tools to label objects. You can mix and match tools when labeling.

* [Smart Labeling](#label-an-object-with-smart-labeling): Click an area to auto-detect objects.  is not available in .
* [Polygons](#label-with-polygons): Create a shape to fill the object you want to detect. You can also use this tool to "erase" labeled regions.
* [Brushes](#label-with-brushes): "Paint" over the object you want to detect. You can also use this tool to "erase" labeled regions.
* [Polylines](#label-with-polylines): Create lines over the object you want to detect.

## Label with Smart Labeling

<iframe title="YouTube video player" />

&#x20;is a labeling tool powered by [SAM 2](https://ai.meta.com/research/sam2/), Meta's open-source Segment Anything Model, that helps you label objects in Segmentation projects faster than using traditional methods.

To use , simply select the tool (or press Q), hover over and click the object you want to select.  automatically detects the shape of the object and adds a gray overlay to it. To confirm that  detected the correct object, press **Return** (Mac) or **Enter** (Windows) to confirm.

<img alt="Smart Label" />

<Info> is not available in .</Info>

### Label an Object with Smart Labeling

To label an object with :

1. Click the  icon if it isn't selected, or press **q**.
2. Select the **Class** you want to label from the drop-down menu.
   <img alt="Smart Labeling" />
3. Hover over the object you want to select. Smart Labeling adds a gray overlay over the object it "thinks" you want to select.
   <img alt="Smart Labeling" />
4. Click the object.  adds a green dot where you clicked. This, along with the gray overlay, help you track what regions you've selected. Clicking the object also adds a blue border to your frame, which indicates that you're using .
   <img alt="Smart Labeling" />
5. If you want to add another region to the same object, hover over that region. The cursor turns into a **+** (plus).
   <img alt="Smart Labeling" />
6. Click the object. Smart Labeling adds a gray overlay to the object and adds a green dot where you clicked.
   <img alt="Smart Labeling" />
7. You can continue to add regions using this method.
   <img alt="Smart Labeling" />
8. Once you've labeled all regions of the object, either click **Save Labels (Return)**, or press **Return** (Mac) or **Enter** (Windows).
   <img alt="Smart Labeling" />
9. Smart Labeling labels the object with the selected Class.
   <img alt="Smart Labeling" />

### Remove a Region from a Selection

Let's say a region gets accidentally added to your selection. While  is selected, you can hover over that region until the cursor turns into a **−** (minus). Then click that region.  removes the selection. When you're done, press **Return** (Mac) or **Enter** (Windows).

To remove a region from an object (assumes that  is enabled, and you just labeled an object):

1. Hover over and click the labeled region. Smart Labeling removes the overlay and adds a red dot where you clicked, which helps you track what regions you've removed.
   <img alt="SmartLabel_remove" />
2. Continue to click selected regions until you've removed all the selections you want.
3. When you're done removing regions, press **Return** (Mac) or **Enter** (Windows).

### Tips for Labeling Multiple Objects in an Image

Let's say you're developing a model that detects tractors in construction sites. When using , we recommend that you label each tractor one at a time, instead of labeling them all at once. In other words, label one tractor, and then press **Return** (Mac) or **Enter** (Windows). *Then* label the second tractor, and so on.

<img alt="smart_individual_objects" />

We don't recommend labeling all tractors at once, and then clicking **Enter**/**Return**. Doing that makes  think that these areas are the same object, and not the same *type* of object. If you do this, you might notice additional areas added to the object that aren't actually part of that object.

## Label with Polygons

The **polygon** tool lets you draw an outline of a shape. After the outline has been completed, the shape will be automatically filled. You can also use this tool to erase labeled regions.

To label with polygons:

1. Open the Segmentation project you want to edit.
2. Open the image you want to label.
3. Click the **Polygon** icon. (You can also press **W** on your keyboard.)
4. Select a class from the drop-down menu.
   <img alt="Polygon Tool" />
5. Click where you want to start your shape. A blue circle displays, indicating the start of the shape.
6. Click to continue creating your shape.
7. Complete your shape by clicking the blue circle. The shape automatically fills with the color of the class.
   <img alt="Polygon Tool" />

## Label with Brushes

The **brush** tool lets you paint over the object of interest. You can also use this tool to erase labeled regions.

To label with brushes:

1. Open the Segmentation project you want to edit.
2. Open the image you want to label.
3. Click the **Brush** icon. (You can also press **B** on your keyboard.)
4. Select a class from the drop-down menu.
   <img alt="Brush Tool" />
5. Adjust the size of the line width accordingly.
6. Click and drag your cursor to "paint" over the area you want to identify.
7. Release the mouse to complete your edits.
   <img alt="Brush Tool" />

### Remove Excess Labels with Brushes

<Info>You can also remove excess labels with Polygons. This process is similar to the procedure in this section. For more information on how to use the Polygon tool, go [here](#label-with-polygons).</Info>
To remove excess labels with a Brush:

1. Open the Segmentation project you want to edit.
2. Open the image you want to label.
3. Click the **Brush** icon. (You can also press **B** on your keyboard.)
4. Click the **Erase** icon. (You can also press **E** on your keyboard.)
   <img alt="Erase with the Brush" />
5. Adjust the size of the eraser accordingly.
6. Click and drag your cursor over the area you want to remove.
7. Release the mouse to complete your edits.
   <img alt="Erase with the Brush" />

## Label with Polylines

The **polyline** tool lets you create lines over the object of interest.

To label with polylines:

1. Open the Segmentation project you want to edit.
2. Open the image you want to label.
3. Click the **Polyline** icon. (You can also press **L** on your keyboard.)
4. Select the class you want to label from the drop-down menu.
   <img alt="Polyline Tool" />
5. Adjust the size of the line width accordingly.
6. Click where you want to start your line.
7. Click to change the direction of your line.
8. Press **Enter** on your keyboard to complete your edits.
   <img alt="Polyline Tool" />


# September 2022 Release Notes
Source: https://landinglens.docs.landing.ai/september-2022-release-notes



## LandingLens Announcement

**On 9/28, LandingLens will be updated and you will see a new user interface (UI).** We've updated the UI to be user-friendly and intuitive for Project and Model creation workflows. With this update, you will be able to easily access Data Insights and Model Training results.

<iframe title="YouTube video player" />

It is important to note that:

* All Projects will seamlessly be updated to the new UI.
* All existing features will continue to be available.

<img alt="New UI" />

## New Features

**LandingLens**

* An **Example Project** has been added to your instance of LandingLens. The Example Project is a pre-loaded, view-only Project to help you get started. It includes a step-by-step tutorial on how to analyze a trained Model. It is recommended to complete this tutorial if you are new to LandingLens.
  <img alt="Example Project" />

**LandingEdge**

* LandingEdge now offers a self-sign-on and default system certification for easier installation.

## Improvements

**LandingLens**

* LandingLens now automatically runs "Check Label Quality" if:
  * You train a Model.
  * You iterate at least one label and retrain a Model.
    <img alt="Label Suggestions" />
* LandingLens now shows your Model's training progress in the sidebar. (Only applicable to users with the updated LandingLens UI.)
  <img alt="Model in Sidebar" />

**LandingEdge**

* Improved Cloud Inference for Segmentation Models.
* Reduced the LandingEdge installer size.

## Fixes

* Fixed issues with the Run Live functionality, including Historical Data,  image collection, and credit reduction. (The credit reduction fix is only relevant to Free Trial users with the updated LandingLens UI.)
* Fixed an issue where images didn't display according to the applied filters in LandingLens.
* Fixed an issue where clicking "Stop Training" resulted in an error, and the Model did not stop training.
* Fixed an issue where invited Members didn't display in the Member list unless you refreshed the browser.
* Fixed an issue where users would be logged out when trying to open the Device page.
* Fixed an issue where Predictions didn't display in the Data Browser.
* Fixed an issue where keyboard shortcuts weren't responding.

## User Interface Changes

As previously mentioned, you will see a new and improved user interface (UI) starting on 9/28. This section describes the updates you will see.

### UI Improvements

* Earlier this year, we introduced updated workflows for creating Projects and Models. These simplified workflows were implemented to help you achieve faster Model Training with better accuracy. These workflows will not be affected by the new UI.
* The term "Defect" has been replaced with "[Class](./classes)".
* The "Defect Book" feature is now called "[Label Book](./manage-label-book)".

### Locate Existing Features from the Previous UI

All existing features will continue to be available. This section describes where to locate existing features in the new UI.

#### Manage Classes or Metadata

Click the Actions Button (horizontal ellipsis) and click\*\* Manage Classes\*\*  or **Manage Metadata** accordingly.

<img alt="Manage Classes or Metadata" />

#### Auto Split

Click the Actions Button (horizontal ellipsis) and click **Auto Split.**

<img alt="Auto%20Split" />

#### Set Splits or Metadata

<img alt="Set Splits or Metadata" />

#### Create Labeling Tasks for Agreement-Based Labeling

<img alt="Agreement Based Labeling" />

#### Review Labeling Tasks

<img alt="Review abeling Tasks" />

For more information, go [here](./agreement-based-labeling).


# Use LandingLens on Snowflake
Source: https://landinglens.docs.landing.ai/snowflake



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✖</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

LandingLens is available in the [Snowflake Marketplace](https://app.snowflake.com/marketplace/listing/GZTYZ12K65D7/landingai-landinglens-visual-ai-platform)! Snowflake customers can use LandingLens natively within Snowflake and create computer vision models leveraging the images they already have securely stored in Snowflake.

Watch the following demo to get inspired for how to use LandingLens for your unique use case!

<iframe title="YouTube video player" />

## Benefits of Using LandingLens on Snowflake

Whether you use LandingLens directly from LandingAI or natively in Snowflake, you get the ability to quickly develop and deploy computer vision models. Using  comes with these additional benefits:

* Maintain data privacy and governance in Snowflake. All data in LandingLens adheres to the security protocols configured in Snowflake.
* Load images from your Snowflake account into LandingLens. No need to download and then re-upload images to LandingLens. The images never leave the security of the Snowflake cloud.
* Manage access to LandingLens using the member controls built into Snowflake. Leverage the role-based access tools you're already familiar with and trust.
* Run Snowflake Copilot on your data to get instant insights.
* Use the combined capabilities of the Snowflake Native App Framework and Snowpark Container Services to build sophisticated applications with a range of configurable hardware options, including GPUs. Then distribute and monetize those applications in Snowflake Marketplace, enabling your customers to securely use those applications within their Snowflake accounts.


# Splits
Source: https://landinglens.docs.landing.ai/splits



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span> (see exceptions below)</td>
    </tr>
  </tbody>
</table>

<Info>The information in this section is not applicable to Visual Prompting.</Info>

Computer vision models are trained based on sets of labeled images. The model training process requires the images to be split into three distinct subsets: the **Train set**, **Dev set**, and **Test set**. These sets are referred to as **splits**.

If the concept of setting splits is new to you, you don't have to worry about it—LandingLens will automatically split your dataset into the sets if you use [Fast Training](./train-models) (the default training method). If you are familiar with splits, you can use various tools in LandingLens to manage and assign splits.

Once a set is assigned to an image (either manually or automatically), the image stays in that set unless it is manually assigned to a different set.

Learn more about splits in the following video tutorial.

<iframe title="YouTube video player" />

## Sets

Each set serves a different purpose during the model training process. The three sets are:

* [Train Set](./splits#train-set)
* [Dev Set](./splits#dev-set)
* [Test Set](./splits#test-set)

### Train Set

The model is trained on the images in the **Train set**. The model learns about patterns and objects of interest from these images.

In Anomaly Detection projects, the Train set can only include Normal images. For more information, go to [Anomaly Detection](./anomaly-detection).

### Dev Set

After the model trains on images from the Train set, it validates its training and predictions on images from the **Dev** set. LandingLens continues to fine-tune the model based on its performance on the Dev set.

The Dev set helps prevent [overfitting](./splits#splits-prevent-overfitting). Overfitting is when a model simply “memorizes” the pictures and doesn’t understand what characteristics to look for when identifying objects of interest.

The "Dev set" is short for "Development set". This set is also known as the “Validation set”.

### Test Set

After the model trains on the Train set and fine-tunes on the Dev set, it makes predictions on images in the Test set. The model hasn't "seen" (been trained on) images from the Test set, so the performance on the Test set provides insights into how well the model performs in real-world scenarios.

We recommend that your Test set be as exhaustive and representative of your actual use case as possible. The Test set is your opportunity to see how well the model will perform on your real-world images.

The “Test set” is also known as the “Holdout set” and the “golden dataset”.

## LandingLens Automatically Assigns Splits in Fast Training

If you haven't assigned splits to your images, LandingLens automatically assigns splits to labeled images during Fast Training (the default training method). By default, LandingLens assigns sets based on the following percentages to *labeled images that don't have sets assigned yet*:

* **Train**: 80%
* **Dev**: 20%

## Splits Prevent Overfitting

In the machine learning world, you can overtrain a computer vision model. This concept is similar to overstudying for, say, a test. For example, what if Jane uses flashcards to study? If Jane studies too much this way, she'll memorize the answers to the questions without understanding why these are the answers or how to arrive at those answers. Models can have similar results if you overtrain them. This concept is called **overfitting**. Here's how it works:

Suppose you have a model trained to detect cats. What if the cats in all the images used for training all have collars on?

<img alt="cat-with-collar" />

If you overtrain your model, the model may learn that an important feature of cats is their collars. In this case, if you deploy your model and show it images of wild cats, the model may not detect these cats because they aren't wearing collars.

Detecting whether your model is overfitting can be tricky, which is why LandingLens offers the solution of splitting your images into different sets during model training.

## Assign Splits

You can assign splits using a few different methods. The following table highlights some of the differences, which can help you pick the right method to use for your specific use case.

| Location/Method                                                       | Are the images already uploaded? | Can you apply splits to multiple images at once? | When to use?                                                                                                                                                                |
| --------------------------------------------------------------------- | -------------------------------- | ------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Fast Training](./train-models)                                       | Yes                              | Yes                                              | You don't understand the concept of splits. LandingLens automatically assigns splits to labeled images during Fast Training.                                                |
| [Image View](./splits#set-splits-in-image-view)                       | Yes                              | No                                               | You don't have many images.                                                                                                                                                 |
| [Build tab](./splits#set-splits-for-multiple-images-in-the-build-tab) | Yes                              | Yes                                              | You want to assign a specific split to multiple images.                                                                                                                     |
| [Upload Page](./splits#set-split-at-upload)                           | No                               | Yes                                              | You're uploading labeled images.<br /><br />If you're using , setting splits at upload is not supported when [loading images](./load-images-from-snowflake) from Snowflake. |
| [Auto Split](./splits#auto-split)                                     | Yes                              | Yes                                              | You want to assign all unlabeled images to the three splits at the same time.                                                                                               |
| [Custom Training](./custom-training#split-setup)                      | Yes                              | Yes                                              | You want to assign all unlabeled images to the three splits at the same time during Custom Training.                                                                        |

Learn more about how to assign splits in the following video tutorial.

<iframe title="YouTube video player" />

### Set Splits in Image View

After you've uploaded images to your project, you can manually split images into different sets one at a time, when viewing an image. To do this:

1. Open the project.
2. Click the image you want to assign to a specific set.
3. Select the set you want to assign the image to from the **Split** drop-down menu.
   <img alt="Split_0" />
4. LandingLens automatically saves this change.

### Set Splits for Multiple Images in the Build Tab

After you've uploaded images to your project, you can manually assign multiple images into a specific set at once. You can repeat this process for each set. To do this:

1. Open the project.
2. Select the images you want to assign to a specific set.
3. Click **Options** in the action bar near the bottom of the screen and select **Set Split**. (You may need to scroll to see this option.)
   <img alt="Split_1" />
4. Select the set you want to assign the images to.
5. Click **Apply**. The images are assigned to the selected set.
   <img alt="Split_2" />
6. To deselect the images, click **Deselect All**.

### Set Split at Upload

<Info>If you're using, setting splits at upload is not supported when [loading images from Snowflake stages](./load-images-from-snowflake).</Info>
If you're uploading labeled images, you can assign a split to all the images you want to upload. Splits can only be assigned to labeled (annotated) images, so splits can only be assigned at upload if the classes/labels are also assigned at upload, which happens in these situations:

* [You're uploading labeled images to Object Detection projects](./upload-labeled-images-od)
* [You're uploading labeled images to Segmentation projects](./upload-labeled-images-seg)
* [You're applying classes to images when uploading to Classification projects](./classification#upload-classified-images)
* [You're applying classes to images when uploading to Anomaly Detection projects](./anomaly-detection)

When you upload images in any of the scenarios listed above, you can select an option from the **Split** drop-down menu on the Upload window.

<img alt="split_upload" />

### Auto Split

You can automatically split images into all three sets at once by using the Auto Split tool. This tool allows you to select what percentage of images with each class to assign to each set. To do this:

1. Open the project.
2. Click the **Actions** button (ellipses) and select **Auto Split**.
   <img alt="AutoSplit_1" />
3. If you want to override sets already assigned to images, select this checkbox: **Include assigned train/dev/test media to reassigned**.
4. Review the **Classes** section. For Object Detection projects, this shows how many bounding boxes are used for each class. For Segmentation and Classification projects, this shows how many images have each class.
   <img alt="AutoSplit_2" />
5. Click **Next**.
6. If you want to adjust the split percentage for all classes at the same, keep this checkbox selected: **Adjust value for all defect types together**. When this checkbox is selected, moving the slider for one class moves the slider for all classes.
7. Adjust the sliders to pick the percentages you want for each set.
   <img alt="AutoSplit_3" />
8. Refer to the charts on the page to preview the split.
9. When you're done adjusting the split percentages, click **Assign Split**.
10. LandingLens shows you the charts to confirm the split. Click **Close**.


# Tags
Source: https://landinglens.docs.landing.ai/tags



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

You can apply tags to images in your projects. Using tags helps you organize and filter the images in your dataset.

For example, let's say that you have images from Camera A and Camera B. You can create a tag for each camera, and apply the tags to the corresponding images. Then, after you train a model, you can filter by all Camera A images, and see how the model performed on those. You can then do the same for Camera B images.

Tags are project-specific; creating a tag in one project doesn't add it to other projects. You can apply multiple tags to each image.

<iframe title="YouTube video player" />

## Apply Tags at Upload

You can add tags to images when you upload them. If you're uploading multiple images at once, the selected tags are applied to all images. To add tags at upload:

1. Open the Upload window. (There are several ways to start the upload process. For more information, go to [Upload Images](./upload-images).)
2. Select the images to upload.
3. Click **Add Tag**.
   <img alt="TagsUpload_1" />
4. Select or create the tags you want to apply.
   <img alt="TagsUpload_2" />
5. Click **Upload Images**.
   <img alt="TagsUpload_3" />
6. LandingLens applies the tags to the uploaded images.
   <img alt="TagsUpload_4" />

## Apply Tags to Individual Images

To apply a tag to an individual image, or to see the tags already applied to it, click the image. The **Tag** panel displays in both the **View** and **Label** tabs. In the **Tag** panel, you can apply, create, and remove tags.

<img alt="TagsPanel" />

## Apply Tags to Multiple Images at Once

You can apply tags to multiple images at once. To do this:

1. Open the project with the images you want to tag.
2. Select the images you want to tag.
3. Click **Options** and select **Add Tags**.
   <img alt="TagsMultipleImages_1" />
4. Select or create the tags you want to apply.
5. Click **Apply**.
   <img alt="TagsMultipleImages_2" />

LandingLens applies the tags to the selected images.

## Remove Tags from Images

There are two ways to remove tags from images:

* **To remove a tag from a specific image**: Open an image and remove the tag from the Tags panel. (This is the same place where you [apply tags to individual images](./tags#apply-tags-to-individual-images).)
* **To remove tags from all images**: You can [delete the tag](./tags#delete-tags). This removes the tag from all images.

## Manage Tags

You can update the tags for a project on the Manage Tags page. To access this page, click the **Actions** button (ellipses) and select **Manage Tags**.

<img alt="ManageTags_1" />

On the **Manage Tags** page, you can:

* [Create tags](./tags#create-tags)
* [Rename tags](./tags#rename-tags)
* [Delete tags](./tags#delete-tags)

<img alt="ManageTags_2" />

### Create Tags

1. Open the project you want to add tags to.
2. Click the **Actions** button (ellipses) and select **Manage Tags**.
   <img alt="ManageTags_1" />
3. Click **Add a New Tag**.
   <img alt="CreateTag_1" />
4. Enter the tag in the **Tag Name** field.
5. Click **Save Tag**.
   <img alt="CreateTag_2" />

### Rename Tags

1. Open the project with the tag you want to rename.
2. Click the **Actions** button (ellipses) and select **Manage Tags**.
   <img alt="ManageTags_1" />
3. Click the **Edit** icon for the tag you want to rename.
   <img alt="EditTag_1" />
4. Enter the tag in the **Tag Name** field.
5. Click **Save Tag**.
   <img alt="EditTag_2" />

### Delete Tags

Deleting a tag automatically removes the tag from all images it's applied to.

1. Open the project with the tag you want to delete.
2. Click the **Actions** button (ellipses) and select **Manage Tags**.
   <img alt="ManageTags_1" />
3. Click the **Delete** icon for the tag you want to delete.
   <img alt="DeleteTag_1" />
4. Click **Yes, delete**.
   <img alt="DeleteTag_2" />


# Train Models
Source: https://landinglens.docs.landing.ai/train-models



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span> (see exceptions below)</td>
    </tr>
  </tbody>
</table>

<iframe title="YouTube video player" />

LandingLens offers two methods for training models:

* **Fast Training**: This is the default option. LandingLens will automatically fine-tune its settings to optimize model training speed.
* **Custom Training**: Also called "Advanced Training". This is an advanced option recommended for users who are familiar with machine learning. Custom Training allows these users to have more granular control over pre-processing transforms and manual hyperparameter tuning. For more information, go to [Custom Training](./custom-training).

## Models Do Not Train on Unlabeled Images

If there are unlabeled images in your dataset, those images will not be used in the model training process. However, LandingLens will display predictions on those images after the model has completed its training. It's important to note that these predictions will not contribute to performance metrics, as metric calculations rely on comparisons with the ground truth.

## Images Are Resized During Model Training

When you train your model, LandingLens resizes all images to make training faster and more effective. This resize does not affect the original images. This means that the original high-resolution images are always available in the Build tab.

When you use Fast Training (the default Train option), all images are auto-resized according to your project type:

| Project Type      | Dimensions for Model Training (in pixels) |
| ----------------- | ----------------------------------------- |
| Object Detection  | Rescaled with padding to 640x640          |
| Segmentation      | Resized to 800x800                        |
| Classification    | Resized to 512x512                        |
| Anomaly Detection | Resized to 480x480                        |
| Visual Prompting  | Resized to 512x512                        |

<Info>If you have large images that include small objects to detect, these objects can be lost due to the automatic resize. You can use [Custom Training](./custom-training) to choose the resize width and height manually. Or, you can resize images before you upload them to LandingLens.</Info>

## Train Models

The easiest way to train a model in LandingLens is to use the **Fast Training** method (simply called "Train" in the user interface). During Fast Training, LandingLens automatically fine-tune its settings to optimize model training speed.

To train a model using Fast Training:

1. Open the project that has the images you want to train on.
2. Click **Train**. If you want to train a model based on a specific snapshot instead, go to [Dataset Snapshots](./dataset-snapshots).
   <img alt="model_FastTrain_1" />
3. LandingLens runs the [model training process](./train-models#model-training-process)and saves the model.
   <img alt="model_FastTrain_2" />
4. After LandingLens creates the model, you can view its predictions directly on the [Build tab](./view-predictions) and see detailed metrics (like its F1 or IoU scores) in the model's [Performance Report](./performance-report).
   <img alt="model_FastTrain_3" />

## Model Training Process

<img alt="modelTrain" />

LandingLens performs the following series of steps when training a model:

1. **Preparing data snapshot**: When the model training process begins, LandingLens saves all the images, labels, and metadata currently in your dataset. You can later access the dataset in [Dataset Snapshots](./dataset-snapshots).
2. **Provisioning GPU**: LandingLens warms up a virtual computer in the cloud that includes a graphics processing unit (GPU). This virtual computer is where the model training occurs.
3. **Training & learning**: LandingLens sends the model's data and details to the virtual computer. This information tells the model how to train itself.
4. **Calculating performance**: LandingLens calculates the metrics for the model, which show how well the model performed. To see these metrics after training, go to the model's [Performance Report](./performance-report).

## View Learning Data During Model Training

During the model training process, you can view the Loss chart and training information by clicking the **View Details** button on the model tile.

<img alt="modelTrainDetails_1" />

This opens a page that displays the training process, Loss chart, and training details.

The Loss chart is calculated on the Train split, which is the split that the model trains on.

During model training, LandingLens calculates the error between the ground truth and the predictions, which is called **loss**. This chart shows the loss over time (in seconds).

If the model improves during the training process, the line goes down toward 0 over time.

<img alt="modelTrainDetails_2" />

<Info>After training is complete, you can view the Loss chart and training information on the model's [Training Information](./training-information) page.</Info>

## End Training

Use **End Training Now** to stop model training *without creating a model*.

For example, if you click **Train** and then realize you need to annotate more images, you can click **End Training Now**, label those images, and then start a new training job.

If you manually end model training:

* No LandingLens credits will be consumed (not applicable if using .)
* LandingLens will not generate a model, even if it started cycling through the dataset. This prevents users from accidentally using incomplete models.
* A [dataset snapshot](./dataset-snapshots) will still be automatically generated.

To end model training:

1. Click the **End Training Now** button on the model tile.
   <img alt="endTrain_11_22_2024_1" />
2. A confirmation pop-up appears. Click **End Training** to confirm.
3. The model tile has the message **Manually Ended**.
   <img alt="endTrain_11_22_2024_2" />

## Train Multiple Models at Once

<Info>Parallel training is not available in .</Info>
When one model is training, you can start training another model. This is helpful if you want to compare performance between multiple datasets or model training settings. Training multiple models at once is sometimes called "parallel training".

Parallel training is available for both the Fast Training and [Custom Training](./custom-training) methods. Up to 10 models can be trained at a time.

Let’s say you want to build two models for the same dataset using Custom Training. You want one model to use 30 epochs and the other to use 40 epochs. You can start training the second model without waiting for the first one to complete. This capability empowers you to run experiments faster.

To see the status of a model, open the **Model list**. Models that are still training have the status **Training in progress**.

<img alt="model_training_status" />

### LandingLens on Snowflake: Training Jobs Are Sequential

The  app uses one GPU, so it can only train one model at a time. You can start multiple training jobs at the same time, and LandingLens will process them sequentially, and not in parallel.

To help you understand where a training job is in the queue, hover over the **timer** in the [Provisioning GPU](./train-models#model-training-process) step during model training. A tooltip displays this information:

* The estimated time it takes to activate (spin up) the GPU.
* How many training jobs are ahead of the current training job in the queue. This count includes training jobs from all projects  and all users in your instance of .

<img alt="LLSF_trainingQueue" />


# Training Information
Source: https://landinglens.docs.landing.ai/training-information



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

Clicking a model on the **Models** page opens the **Training Information** tab. This tab shows basic information about the model and the dataset it was trained on.

Highlights include:

<img alt="training_info_validation_1" />

<img alt="training_info_validation_2" />

| # | Item                                            | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| - | ----------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| 1 | Loss Chart                                      | See [Loss Chart](#loss-chart)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| 2 | Validation Chart                                | The Validation chart is calculated on the Dev split. This chart displays when the model was trained using [Custom Training](./custom-training) and the Dev split has at least 6 images.<br /><br />If the model improves during the validation process, the line goes up over time. The line will look slightly different for each project type because each uses a different validation metric:<ul><li>**Object Detection**: mAP (Mean Average Precision)</li><li>**Segmentation**: mIoU (mean Intersection over Union)</li><li>**Classification and Anomaly Detection**: F1 score</li></ul> |
| 3 | Trained From                                    | The name of the dataset [snapshot](./dataset-snapshots) that the model was trained on.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| 4 | Split                                           | Shows how many images are in each split.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| 5 | View Images                                     | Click **View Images** to see the dataset [snapshot](./dataset-snapshots) that the model was trained on.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| 6 | Hyperparameter<br />Transform<br />Augmentation | The configurations used to train the model.<br /> <br />For Fast Training (default configuration), this includes **Hyperparameters**, which are the number of epochs and model size.<br /> <br />For Custom Training (customized configuration), this also includes any **Transforms** and **Augmentations**. For more information about these configurations, go to [Custom Training](./custom-training).                                                                                                                                                                                    |

## Loss Chart

The Loss chart is calculated on the Train split, which is the split that the model trains on.

During model training, LandingLens calculates the error between the ground truth and the predictions, which is called **loss**. This chart shows the loss over time (in seconds).

If the model improves during the training process, the line goes down toward 0 over time.


# Upload Folders
Source: https://landinglens.docs.landing.ai/upload-folders



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

LandingLens simplifies folder structures and flattens all files. Let's say you have one folder (Folder A) and two subfolders (Folder B and C). If you upload Folder A, LandingLens will upload all images from Folders A, B, and C, as if they came from the same folder.

<img alt="Flatten Folders" />

However, if you upload "Classified images" to a [Classification](./classification) project, LandingLens will ignore any subfolders. Referring to the example above, if you upload Folder A, only the images in Folder A will be uploaded; the images in Folders B and C will not be uploaded.

<img alt="LandingLens Ignore Subfolder for Classification" />


# Upload Images
Source: https://landinglens.docs.landing.ai/upload-images



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span> (see exceptions below)</td>
    </tr>
  </tbody>
</table>

<iframe title="YouTube video player" />

After you create a project, upload images to it. LandingLens will train a model based on the images you upload and label.

## Supported Files Types

| File Type  | More Information                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| ---------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| PNG        | Recommended file type                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| BMP        | N/A                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| JPG/JPEG   | N/A                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| TIF/TIFF   | TIFFs can be uploaded to LandingLens projects, and are converted to PNGs at upload.<br /><br />LandingLens offers limited support for running inference on TIFFs:<ul><li>**Cloud deployment**: Supports inference but images won't display on the [Deploy](./historical-data) page.</li><li>**LandingEdge**: Supports inference. For multi-frame TIFFs, will run inference on the first frame.</li><li>**Docker**: Supports inference. For multi-frame TIFFs, will run inference on the first frame. </li><li>**Try model / Try this model**: Does not support inference.</li></ul> |
| MPO        | An MPO file is a Multi-Picture Object file. It contains two JPG files that create a stereoscopic image when overlaid. When you upload an MPO file to LandingLens, LandingLens selects one of the two JPG files.<br /><br />Sometimes, a JPG from a smart phone might be interpreted as an MPO because it contains the main image and an embedded thumbnail. In this case, LandingLens selects the main image.                                                                                                                                                                       |
| Pascal VOC | Available only for Object Detection projects. For more information, go to [Upload Labeled Images to Object Detection Projects](./upload-labeled-images-od).<br /><br />If using , uploading Pascal VOC files is not supported when [loading images](./load-images-from-snowflake) from Snowflake.                                                                                                                                                                                                                                                                                   |

<Info>Do you have DICOM (Digital Imaging and Communications in Medicine) files or images in another non-supported file format? Convert them to PNGs first, and then upload them to LandingLens.</Info>

## Image Size

When uploading images to LandingLens, the maximum image size is based on project type. All image size maximums are based on the *number of pixels* (and not based on image file size).

| Project Type                                                                      | Image Size Maximum                                                               |
| --------------------------------------------------------------------------------- | -------------------------------------------------------------------------------- |
| Object Detection<br />Classification<br />Anomaly Detection<br />Visual Prompting | 100MP<br />(images larger than 36MP will load very slowly in the user interface) |
| Segmentation                                                                      | 36MP                                                                             |

<Info>Images might be resized when training a model. For more information, go to [Model Training](./train-models).</Info>

### How Do I Know How Many Pixels My Image Has?

The image size maximums are based on the number of pixels. You can see an image's dimensions in image editors like Photoshop and Illustrator. You can also see the dimensions directly on your computer, without needing to open the image in an application. See the instructions below.

#### View Image Dimensions on a Mac

1. Right-click the image and select **Get Info**.
   <img alt="image_dimensions_mac" />
2. Expand the **More Info** section.
3. The **Dimensions** line gives you the image dimensions (in pixels). Multiply the two dimensions together to get the total number of pixels.
   <br />For example, if the dimensions are 4000x3000, the total number of pixels is 12 million, which is 12MP. That means you can upload the image to any project type.
   <img alt="image_dimensions_mac_02" />

#### View Image Dimensions in Windows

1. Right-click the image and select **Properties**.
   <img alt="properties-windows_2" />
2. Click the **Details** tab.
3. The **Dimensions** line gives you the image dimensions (in pixels). Multiply the two dimensions together to get the total number of pixels.
   <br />For example, if the dimensions are 250x250, the total number of pixels is 625,000, which is 62.5KP. That means you can upload the image to any project type.
   <img alt="dimensions-windows_2" />

### What If My Image Has Too Many Pixels?

If you attempt to upload an image that is over the maximum image size (which is in pixels), you'll get an error message.

As a short-term solution, resize your image in an image editor like Photoshop or Illustrator, and then upload the image again.

As a long-term solution, adjust your camera settings so that the new images are below the maximum number of pixels. This might include lowering the resolution or changing the aspect ratio.

## Number of Labeled Images in a Project

The maximum number of labeled images a model can use for training depends on the project type.

| Project Type      | Maximum Number of Labeled Images                                               |
| ----------------- | ------------------------------------------------------------------------------ |
| Object Detection  | 10,000 images                                                                  |
| Segmentation      | 10,000 images<br />                                                            |
| Classification    | 10,000 images<br />                                                            |
| Anomaly Detection | 1,000 images                                                                   |
| Visual Prompting  | 20 images (for more information, go to [Visual Prompting](./visual-prompting)) |

## Number of Images Required for a Project

You must upload and label at least 10 images before training a model.

Since every use case is different, there is no recommended number of images for projects. For detailed best practices, go to [Curate High-Quality Datasets](./curate-high-quality-datasets).

## Upload Options

LandingLens offers the following methods for uploading images to your project. Click the hyperlink for each method to learn more.

| Upload Method                                                                                         | Description                                                                                                                                                                                                                                                          |
| ----------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Drag and drop](./drag-and-drop-images)                                                               | Select the files or folders you want to upload, and drag and drop them into an Upload pop-up window or directly into the project.                                                                                                                                    |
| [Upload images from a directory](./upload-images-from-a-directory)                                    | Some Upload pop-up windows offer the option to select files from a directory. Select the files or folders you want to upload and click **Open**.                                                                                                                     |
| [Upload sample images](./upload-sample-images)                                                        | If you haven't added any images to a project, you have the option to upload a sample dataset. To add the sample images, click **Load Sample Data** and select a dataset. The available datasets are based on the project type.<br /><br />This is not available in . |
| [Take photos with your webcam](./upload-images-webcam)                                                | Click the **Webcam** option and take photos with your computer webcam.<br /><br />This is not available in .                                                                                                                                                         |
| [Upload images from your phone](./upload-images-phone)                                                | Choose this option to generate a QR code in LandingLens. Scan that code with your smart phone, and then upload images from your phone directly to your project.<br /><br />This is not available in .                                                                |
| [Upload labeled images to Object Detection projects](./upload-labeled-images-od)                      | Upload images in the Pascal VOC file format.<br /><br />If you're using , uploading Pascal VOC files is not supported when [loading images](./load-images-from-snowflake) from Snowflake.                                                                            |
| [Upload labeled images to Segmentation projects](./upload-labeled-images-seg)                         | Upload images with Segmentation masks.<br /><br />If you're using , uploading Segmentation masks is not supported when [loading images](./load-images-from-snowflake) from Snowflake.                                                                                |
| [Label images at upload for Classification projects](./classification)                                | Create folders named after the classes you want to use. Put images in their respective folders, and then upload the folders to the project using the Classified Images Upload workflow.                                                                              |
| [Label images at upload for Anomaly Detection projects](./anomaly-detection)                          | Open an Anomaly Detection project and use the on-screen instructions to label images as Normal or Abnormal at upload.                                                                                                                                                |
| [Upload images via LandingEdge](./landingedge/upload-images-to-landinglens-without-running-inference) | Upload images with LandingEdge.                                                                                                                                                                                                                                      |
| [Load images from Snowflake](./load-images-from-snowflake)                                            | If you're using , you can load images from a Snowflake stage.                                                                                                                                                                                                        |
| [Load sample datasets from Snowflake Marketplace](./load-images-from-snowflake)                       | If you're using , you can load sample datasets from LandingAI in the Snowflake Marketplace.                                                                                                                                                                          |

## Upload Images to a New Project vs. a Project that Already Has Images

If you haven't uploaded images to a project yet, all of the upload options appear directly on the project page.

<img alt="Upload_NewProject" />

After you've uploaded images to a project, click the **Upload** icon to see the upload options. Or, you can drag and drop images directly into the project page.

## Detect Duplicate Images

LandingLens automatically prevents duplicate images from being uploaded to a project. When you upload an image to a project, LandingLens checks the MD5 checksum of the image. If another image in the project has the same MD5 checksum, LandingLens doesn't upload the image and displays an error message that explains the image is already in the project.


# Upload Images from a Directory
Source: https://landinglens.docs.landing.ai/upload-images-from-a-directory



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

You can upload a directory (folder) of images into a project.

<img alt="SelectImages_Low" />

To upload images from a directory into a project:

1. Open the project you want to upload images to.
2. Open the Upload pop-up window:
   * If you haven't uploaded any images to the project yet, click the **Drop to Upload** icon.
     <img alt="SelectImages_New" />
   * If you've already uploaded images, click the **Upload** icon.
     <img alt="DragDrop_0(2)" />
3. Click the upload box to search for and select the images you want to upload.
   <img alt="SelectImages_1" />
4. A preview of your images displays. To confirm your upload, click the **Upload** button.
   <img alt="SelectImages_2" />
5. LandingLens uploads the images to your project.


# Upload Images from Your Phone
Source: https://landinglens.docs.landing.ai/upload-images-phone



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✖</span></td>
    </tr>
  </tbody>
</table>

<iframe title="YouTube video player" />

You can upload photos from your phone into a project in LandingLens. You can either select existing photos, or take new ones.

To upload photos, LandingLens generates a QR code that is unique to the project. You then scan the QR code to open the LandingLens app in your phone browser. From there, you can take a photo or select one from your phone. The app uploads the selected photos directly to your project.

You can also share the QR code with your colleagues, so that you can all collaborate on uploading images.

For security reasons, each QR code expires in 24 hours. After that, you can generate a new one. You can also [deactivate a QR code](./upload-images-phone#deactivate-a-qr-code) at any time.

## Upload Images from Your Phone to a Project

To upload photos from your phone:

1. Open the project you want to upload images to.
2. Open the Upload pop-up window:
   * If you haven't uploaded any images to the project yet, click **Click here**.
     <img alt="qr_upload_newproj(2)" />
   * If you've already uploaded images, click the **Upload** icon.
     <img alt="qr_upload_existing_proj" />
3. Click **Upload from Your Phone**.
   <img alt="qr_upload_1" />
4. Click **Get QR Code** on the pop-up window that opens.
   <img alt="qr_upload_2" />
5. A QR code that is unique to this project displays. Turn on your phone’s camera app, and hold up your phone to the QR code.
6. Click the pop-up that appears at the top of your phone.
   <img alt="qr_upload_3" />
7. The LandingLens app opens in your browser. Click **Select a Photo** and select one of these options to get an image:
   * **Photo Library**: Select an image saved to your phone.
   * **Take Photo**: Use the Camera app on your phone to take a photo.
   * **Choose File**: Select a file saved to your phone.
     <img alt="select_photo" />
8. After you select or take a photo, the app sends the photo to your project.
9. You can keep taking photos—just click **Select a Photo** to continue.
10. When you're done taking or selecting photos, you can close the tab on your phone's browser.
11. Back in LandingLens, close the QR code pop-up window and the Upload Images pop-up window.
12. Refresh the page (you can click in the URL bar and press **Enter**/**Return**).
    <Info>The uploaded images won't display until the page is refreshed.</Info>
13. All the photos you’ve taken display in your project.

## Deactivate a QR Code

You can deactivate the QR code for uploading images at any time by clicking **Turn It Off** on the QR code pop-up window. When the QR code is deactivated, no one with the QR code can use it to upload images to your project.

<img alt="qr_upload_deactivate" />

Deactivating the QR code can be useful in multiple situations. For example, you can deactivate it if you have a time-bound project, and don't want to add more data after the end of the project.

To reactivate a QR code, simply follow the procedure in [Upload Images from Your Phone to a Project](./upload-images-phone#upload-images-from-your-phone-to-a-project).

## Expired QR Code

A QR code expires 24 hours after it's generated. To create a new one, click the **Refresh** icon or **Get New QR Code**.

<img alt="qr_getnewcode" />


# Upload Images from a Webcam
Source: https://landinglens.docs.landing.ai/upload-images-webcam



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✖</span></td>
    </tr>
  </tbody>
</table>

<iframe title="YouTube video player" />

You can take photos with your webcam and upload them to a project in LandingLens. To upload photos from your webcam:

1. Open the project you want to upload images to.
2. Open the Upload pop-up window:
   * If you haven't uploaded any images to the project yet, click **Use WebCam**.
     <img alt="WebCam_NewProject" />
   * If you've already uploaded images, click the **Upload** icon and select **Turn on Webcam**.
     <img alt="WebCam_1" />
3. The first time you upload images from a webcam, your might be prompted to grant LandingLens access to your webcam.
   <img alt="Allow Webcam" />
4. Click the **Capture** button each time you want to take a photo with your webcam.
   <img alt="WebCam_2" />
5. (Optional) If you also want to upload images from your computer, click **Turn off Webcam**. You can then [drag and drop images](./drag-and-drop-images) into the project, or [select images from a directory](./upload-images-from-a-directory).
   <img alt="WebCam_3" />
6. A preview of your images displays. To confirm your upload, click the **Upload** button.
   <img alt="WebCam_4" />


# Upload Labeled Images to Object Detection Projects
Source: https://landinglens.docs.landing.ai/upload-labeled-images-od



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span> (see exceptions below)</td>
    </tr>
  </tbody>
</table>

<iframe title="YouTube video player" />

If you have labeled images you want to upload to Object Detection projects, you can upload them in the [Pascal VOC](http://host.robots.ox.ac.uk/pascal/VOC/) (Visual Object Classes) format. This format involves uploading the original (unlabeled) image and a corresponding XML file. The XML file contains the label (annotation) details of its paired image. The XML file essentially tells LandingLens where each label is on its associated image and what the name of the class is.

The image and XML file must have the same file name (with different extensions). For example:

* vehicle\_123.png
* vehicle\_123.xml

<Info>If you're using , uploading Pascal VOC files is not supported whenloading imagesfrom Snowflake stages. You can still upload the files from a hard drive.</Info>

## Pascal VOC XML Files

When you upload an image and its corresponding XML file to an Object Detection project in LandingLens, the XML file must follow the format of the following code sample:

```bash theme={null}
<?xml version='1.0' encoding='UTF-8'?>
<annotation>
  <object>
    <pose>Unspecified</pose>
    <occluded>0</occluded>
    <difficult>0</difficult>
    <truncated>0</truncated>
    <name>Diamond</name>
    <labeler>0f7936ab-7025-482f-9812-4d9c778e00f6</labeler>
    <bndbox>
      <xmax>926</xmax>
      <xmin>652</xmin>
      <ymax>3046</ymax>
      <ymin>2808</ymin>
    </bndbox>
  </object>
</annotation>
```

### Pascal VOC Elements

The following table explains the elements in the Pascal VOC XML file.

| Element                                  | Definition                                                                                                                                                                                                                                                                                                                                                                                          | Example                                  |
| ---------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------- |
| `<?xml version='1.0' encoding='UTF-8'?>` | The XML preamble that defines the XML standard and encoding method.                                                                                                                                                                                                                                                                                                                                 | `<?xml version='1.0' encoding='UTF-8'?>` |
| `<annotation>`                           | This element wraps around all objects.                                                                                                                                                                                                                                                                                                                                                              | `<annotation>`                           |
| `<object>`                               | This element wraps around all elements that define the labeled object.                                                                                                                                                                                                                                                                                                                              | `<object>`                               |
| `<pose>`                                 | Identifies if the image is skewed. The default value is `Unspecified`, which means that the image is not skewed.                                                                                                                                                                                                                                                                                    | `<pose>Unspecified</pose>`               |
| `<occluded>`                             | Indicates if the labeled object overlaps another labeled object.<br /><br />Values:<ul><li>The labeled object is not overlapped: `0`</li><li>The labeled object is overlapped: `-1`</li></ul>                                                                                                                                                                                                       | `<occluded>0</occluded>`                 |
| `<difficult>`                            | Indicates if the object is easy to detect.<br /><br />Values:<ul><li>The object is easy to detect: `0`</li><li>The object is difficult to detect: `-1`</li></ul>                                                                                                                                                                                                                                    | `<difficult>0</difficult>`               |
| `<truncated>`                            | Indicates if a bounding box doesn't include the full object. This could happen because the object isn't fully in the frame (ex: the object is a cat but it's only halfway in the picture) or because there is something in front of the object.<br /> <br />Values:<ul><li>The bounding box includes the full object: `0`</li><li>The bounding box does not include the full object: `-1`</li></ul> | `<truncated>0</truncated>`               |
| `<name>`                                 | The name of the class (label). When the image and the corresponding XML file are uploaded to LandingLens, LandingLens converts this name into a class.                                                                                                                                                                                                                                              | `<name>Diamond</name>`                   |
| `<bndbox>`                               | This element wraps around the dimensions for the edges of the bounding box, which is the rectangle around the labeled object.                                                                                                                                                                                                                                                                       | `<bndbox>`                               |
| `<xmax>`                                 | The distance from the **left edge** of the image to the **right side** of the bounding box (in pixels).                                                                                                                                                                                                                                                                                             | `<xmax>1032</xmax>`                      |
| `<xmin>`                                 | The distance from the **left edge** of the image to the **left side** of the bounding box (in pixels).                                                                                                                                                                                                                                                                                              | `<xmin>2085</xmin>`                      |
| `<ymax>`                                 | The distance from the **top** of the image to the **bottom side** of the bounding box (in pixels).                                                                                                                                                                                                                                                                                                  | `<ymax>2800</ymax>`                      |
| `<ymin>`                                 | The distance from the **top** of the image to the **top side** of the bounding box (in pixels).                                                                                                                                                                                                                                                                                                     | `<ymin>2396</ymin>`                      |
| `<filename>`                             | The file name and image file extension of the image.                                                                                                                                                                                                                                                                                                                                                | `<filename>IMG_6397.jpg</filename>`      |
| `<segmented>`                            | Indicates if any of the bounding boxes are not rectangles (for example if one is a hexagon).<br /><br />Values:<ul><li>All bounding boxes are rectangles: `0`</li><li>At least one bounding box is not a rectangle: `-1`</li></ul>                                                                                                                                                                  | `<segmented>0</segmented>`               |
| `<size>`                                 | This element wraps around the dimensions of the image.                                                                                                                                                                                                                                                                                                                                              | `<size>`                                 |
| `<height>`                               | The height of the image (in pixels).                                                                                                                                                                                                                                                                                                                                                                | `<height>4032</height>`                  |
| `<width>`                                | The width of the image (in pixels).                                                                                                                                                                                                                                                                                                                                                                 | `<width>3024</width>`                    |

### Convert to Pascal VOC

If you have images annotated in a format that is NOT Pascal VOC, you can use the Python scripts in this section to convert from [YOLO](./upload-labeled-images-od#convert-from-yolo-to-pascal-voc) or [COCO](./upload-labeled-images-od#convert-from-coco-to-pascal-voc) to Pascal VOC.

To convert from other formats, use a third-party conversion tool to convert the files to Pascal VOC. Then upload the images and the XML files to LandingLens.

#### Convert from YOLO to Pascal VOC

Use the following Python script to convert images from YOLO to Pascal VOC:

```python theme={null}
import argparse
import os
import sys
import shutil

import cv2
from lxml import etree, objectify

# Write label information to xml
from tqdm import tqdm

images_nums = 0
category_nums = 0
bbox_nums = 0


def save_anno_to_xml(filename, size, objs, save_path):
    E = objectify.ElementMaker(annotate=False)
    anno_tree = E.annotation(
        E.folder("DATA"),
        E.filename(filename),
        E.source(
            E.database("The VOC Database"),
            E.annotation("PASCAL VOC"),
            E.image("flickr")
        ),
        E.size(
            E.width(size[1]),
            E.height(size[0]),
            E.depth(size[2])
        ),
        E.segmented(0)
    )
    for obj in objs:
        E2 = objectify.ElementMaker(annotate=False)
        anno_tree2 = E2.object(
            E.name(obj[0]),
            E.pose("Unspecified"),
            E.truncated(0),
            E.difficult(0),
            E.bndbox(
                E.xmin(obj[1][0]),
                E.ymin(obj[1][1]),
                E.xmax(obj[1][2]),
                E.ymax(obj[1][3])
            )
        )
        anno_tree.append(anno_tree2)
    anno_path = os.path.join(save_path, filename[:-3] + "xml")
    etree.ElementTree(anno_tree).write(anno_path, pretty_print=True)


def xywhn2xyxy(bbox, size):
    bbox = list(map(float, bbox))
    size = list(map(float, size))
    xmin = (bbox[0] - bbox[2] / 2.) * size[1]
    ymin = (bbox[1] - bbox[3] / 2.) * size[0]
    xmax = (bbox[0] + bbox[2] / 2.) * size[1]
    ymax = (bbox[1] + bbox[3] / 2.) * size[0]
    box = [xmin, ymin, xmax, ymax]
    return list(map(int, box))


def parseXmlFilse(image_path, anno_path, save_path):
    global images_nums, category_nums, bbox_nums
    assert os.path.exists(image_path), "ERROR {} dose not exists".format(image_path)
    assert os.path.exists(anno_path), "ERROR {} dose not exists".format(anno_path)
    if os.path.exists(save_path):
        shutil.rmtree(save_path)
    os.makedirs(save_path)

    category_set = []
    with open(anno_path + '/classes.txt', 'r') as f:
        for i in f.readlines():
            category_set.append(i.strip())
    category_nums = len(category_set)
    category_id = dict((k, v) for k, v in enumerate(category_set))

    images = [os.path.join(image_path, i) for i in os.listdir(image_path)]
    files = [os.path.join(anno_path, i) for i in os.listdir(anno_path)]
    images_index = dict((v.split(os.sep)[-1][:-4], k) for k, v in enumerate(images))
    images_nums = len(images)

    for file in tqdm(files):
        if os.path.splitext(file)[-1] != '.txt' or 'classes' in file.split(os.sep)[-1]:
            continue
        if file.split(os.sep)[-1][:-4] in images_index:
            index = images_index[file.split(os.sep)[-1][:-4]]
            img = cv2.imread(images[index])
            shape = img.shape
            filename = images[index].split(os.sep)[-1]
        else:
            continue
        objects = []
        with open(file, 'r') as fid:
            for i in fid.readlines():
                i = i.strip().split()
                category = int(i[0])
                category_name = category_id[category]
                bbox = xywhn2xyxy((i[1], i[2], i[3], i[4]), shape)
                obj = [category_name, bbox]
                objects.append(obj)
        bbox_nums += len(objects)
        save_anno_to_xml(filename, shape, objects, save_path)


if __name__ == '__main__':
    """
    Script Description:
        This script is used to convert annotation file .txt in yolo format to annotation file .xml in voc format
    Parameter description:
        anno_path:txt storage path of the annotation file.
        save_path:the folder where the json file will be output.
        image_path:path of the image.
    """
    parser = argparse.ArgumentParser()
    parser.add_argument('-ap', '--anno-path', type=str, default='./data/labels/yolo', help='yolo txt path')
    parser.add_argument('-s', '--save-path', type=str, default='./data/convert/voc', help='xml save path')
    parser.add_argument('--image-path', default='./data/images')

    opt = parser.parse_args()
    if len(sys.argv) > 1:
        print(opt)
        parseXmlFilse(**vars(opt))
        print("image nums: {}".format(images_nums))
        print("category nums: {}".format(category_nums))
        print("bbox nums: {}".format(bbox_nums))
    else:
        anno_path = './data/labels/yolo'
        save_path = './data/convert/voc1'
        image_path = './data/images'
        parseXmlFilse(image_path, anno_path, save_path)
        print("image nums: {}".format(images_nums))
        print("category nums: {}".format(category_nums))
        print("bbox nums: {}".format(bbox_nums))
```

#### Convert from COCO to Pascal VOC

Use the following Python script to convert images from COCO to Pascal VOC:

```python theme={null}
from pycocotools.coco import COCO
import os
from lxml import etree, objectify
import shutil
from tqdm import tqdm
import sys
import argparse


# index name and id
def catid2name(coco):
    classes = dict()
    for cat in coco.dataset['categories']:
        classes[cat['id']] = cat['name']
    return classes


# write the label to xml
def save_anno_to_xml(filename, size, objs, save_path):
    E = objectify.ElementMaker(annotate=False)
    anno_tree = E.annotation(
        E.folder("DATA"),
        E.filename(filename),
        E.source(
            E.database("The VOC Database"),
            E.annotation("PASCAL VOC"),
            E.image("flickr")
        ),
        E.size(
            E.width(size['width']),
            E.height(size['height']),
            E.depth(size['depth'])
        ),
        E.segmented(0)
    )
    for obj in objs:
        E2 = objectify.ElementMaker(annotate=False)
        anno_tree2 = E2.object(
            E.name(obj[0]),
            E.pose("Unspecified"),
            E.truncated(0),
            E.difficult(0),
            E.bndbox(
                E.xmin(obj[1]),
                E.ymin(obj[2]),
                E.xmax(obj[3]),
                E.ymax(obj[4])
            )
        )
        anno_tree.append(anno_tree2)
    anno_path = os.path.join(save_path, filename[:-3] + "xml")
    etree.ElementTree(anno_tree).write(anno_path, pretty_print=True)


def load_coco(anno_file, xml_save_path):
    if os.path.exists(xml_save_path):
        shutil.rmtree(xml_save_path)
    os.makedirs(xml_save_path)

    coco = COCO(anno_file)
    classes = catid2name(coco)
    imgIds = coco.getImgIds()
    classesIds = coco.getCatIds()
    for imgId in tqdm(imgIds):
        size = {}
        img = coco.loadImgs(imgId)[0]
        filename = img['file_name']
        width = img['width']
        height = img['height']
        size['width'] = width
        size['height'] = height
        size['depth'] = 3
        annIds = coco.getAnnIds(imgIds=img['id'], iscrowd=None)
        anns = coco.loadAnns(annIds)
        objs = []
        for ann in anns:
            object_name = classes[ann['category_id']]
            # bbox:[x,y,w,h]
            bbox = list(map(int, ann['bbox']))
            xmin = bbox[0]
            ymin = bbox[1]
            xmax = bbox[0] + bbox[2]
            ymax = bbox[1] + bbox[3]
            obj = [object_name, xmin, ymin, xmax, ymax]
            objs.append(obj)
        save_anno_to_xml(filename, size, objs, xml_save_path)


def parseJsonFile(data_dir, xmls_save_path):
    assert os.path.exists(data_dir), "data dir:{} does not exits".format(data_dir)

    if os.path.isdir(data_dir):
        data_types = ['train2017', 'val2017']
        for data_type in data_types:
            ann_file = 'instances_{}.json'.format(data_type)
            xmls_save_path = os.path.join(xmls_save_path, data_type)
            load_coco(ann_file, xmls_save_path)
    elif os.path.isfile(data_dir):
        anno_file = data_dir
        load_coco(anno_file, xmls_save_path)


if __name__ == '__main__':
    """
    Script Description:
        This script is used to convert json files in coco format to xml files in voc format
    Parameter Description:
        data_dir:path of the json file
        xml_save_path:path of the xml output.
    """

    parser = argparse.ArgumentParser()
    parser.add_argument('-d', '--data-dir', type=str, default='./data/labels/coco/train.json', help='json path')
    parser.add_argument('-s', '--save-path', type=str, default='./data/convert/voc', help='xml save path')
    opt = parser.parse_args()
    print(opt)

    if len(sys.argv) > 1:
        parseJsonFile(opt.data_dir, opt.save_path)
    else:
        data_dir = './data/labels/coco/train.json'
        xml_save_path = './data/convert/voc'
        parseJsonFile(data_dir=data_dir, xmls_save_path=xml_save_path)
```

## Upload Images and Their XML Files

<Info>If you're using , uploading Pascal VOC files is not supported when [loading images from Snowflake stages](./load-images-from-snowflake). You can still upload the files from a hard drive.</Info>
Before uploading labeled images, ensure that they are not in a zipped file. LandingLens doesn't support uploading zipped files.

Once you've located your image files, XML files, and ensure that they have the same name, follow the instructions below to upload the Pascal VOC files to LandingLens:

1. Open the Object Detection project you want to upload images to.
2. Open the Upload pop-up window:
   * If you haven't uploaded any images to the project yet, scroll down to the bottom of the page and click **Click Here**.
     <img alt="UploadPascalVOC_NewProject" />
   * If you've already uploaded images, click the **Upload** icon.
     <img alt="UploadPascalVOC_1" />
3. [Drag and drop](./drag-and-drop-images) the images and Pascal VOC XML files into the project. You can also select the files from a [directory](./upload-images-from-a-directory). The image and XML file must have the same file name (with different extensions).
4. A preview of your images displays. If an image has a correctly-formatted XML file, LandingLens captions it as **Pascal Voc**.
5. To confirm your upload, click the **Upload** button.
   <img alt="UploadPascalVOC_2(1)" />
6. The pre-labeled images display in your project.
   <img alt="UploadPascalVOC_3(1)" />


# Upload Labeled Images to Segmentation Projects
Source: https://landinglens.docs.landing.ai/upload-labeled-images-seg



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span> (see exceptions below)</td>
    </tr>
  </tbody>
</table>

<iframe title="YouTube video player" />

You can upload pre-labeled images into Segmentation projects by uploading the images and their Segmentation Masks. A Segmentation Mask is a PNG file that you upload along with the image. The Segmentation Mask identifies each detected area.

When you open the Upload pop-up window, you can select the Upload Labeled Images option. Then you upload each file type:

1. Image: Upload your images.
2. [Segmentation mask](#segmentation-mask): Upload the PNGs of your segmentation masks.
3. [Defect Map](#defect-map): Upload the JSON file with the defect map.

<Info>If you're using , uploading labeled segmentation images is not supported when [loading images from Snowflake stages](./load-images-from-snowflake). You can still upload the files from a hard drive.</Info>

### Segmentation Mask

The Segmentation Masks must be PNG files. The Segmentation Mask is an 8-bit grayscale bitmap of the image in which each intensity represents a class. If you open the Segmentation Mask file, it looks like the image is all black. However, when you upload the image and its Segmentation Mask to LandingLens, you will see the mask as a label.

For example, the images below show the 1) original image, 2) the Segmentation Mask in an image editor, and 3) the Segmentation Mask applied to the image in LandingLens.

<img alt="2023-03-22T20-28-47-766Z-2022-08-18T18-21-15-517Z-pill_7(1)" />

<img alt="2023-03-22T20-28-47-766Z-2022-08-18T18-21-15-517Z-pill_7_mask" />

<img alt="Seg_applied" />

The Segmentation Mask files must have the same names as the image files. If the image is a PNG, you must store the image and mask in separate folders before uploading. Otherwise, your computer may overwrite one file with the other.

You can create Segmentation Masks using open-source, third-party tools.

### Defect Map

The Defect Map is a JSON file that defines the class names for your project. The Defect Map must follow this format:

```json theme={null}
{
  "0": "ok",
  "1": "Class Name",
  "2": "Class Name"
}
```

The value for “0” must be “ok”. “0” is used to identify the background; in other words, areas that do not have classes applied to them. The value “ok” will not be created as a class. If you don’t include this line, you will get an error when you try to upload the images.

Enter your class names starting with “1”. For example, let’s say you have two classes: Chip and Scratch. You would format the Defect Map like this:

```json theme={null}
{
  "0": "ok",
  "1": "Chip",
  "2": "Scratch"
}
```

### Upload Labeled Images

<Info>If you're using , uploading labeled segmentation images is not supported when [loading images from Snowflake stages](./load-images-from-snowflake). You can still upload the files from a hard drive.</Info>
Once you've located your image files, Segmentation Masks, and Defect Maps, follow the instructions below to upload the files to LandingLens:

1. Open the Segmentation project you want to upload images to.
2. Open the Upload pop-up window.
   * If you haven't uploaded any images to the project yet, scroll down to the bottom of the page and click **Click Here**.
     <img alt="Upload Segmentation Images" />
   * If you've already uploaded images, click the **Upload** icon.
     <img alt="UploadSeg_ProjectWithImages" />
3. Select **Upload labeled images** from the drop-down menu.
   <img alt="UploadSeg_labeled_1" />
4. Upload your images in the **Image** tile. Drag and drop the files here, or click **Choose File**.<br />The number of files displays below the tile. The number of files displays below the tile. The images display in the **Upload Preview** section.
   <img alt="UploadSeg_labeled_2" />
5. Upload the Segmentation Masks in the **Segmentation mask** tile. Drag and drop the files here, or click **Choose File**.<br />The number of files displays below the tile. In the **Upload Preview** section, every image that has a mask is now marked as *Labeled*. Images that don’t have masks are marked as *Unlabeled*.
   <img alt="UploadSeg_labeled_3" />
6. Upload the Defect Map to the **Defect map** tile. Drag and drop the file here, or click **Choose File**.<br />The file name displays below the tile.
   <img alt="UploadSeg_labeled_4" />
7. Click **Upload Images**. LandingLens shows the upload progress.
   <img alt="UploadSeg_labeled_5" />
   When the upload is complete, all images that have masks are labeled.
   <img alt="UploadSeg_labeled_6" />


# Upload Sample Images to a New Project
Source: https://landinglens.docs.landing.ai/upload-sample-images



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✖</span></td>
    </tr>
  </tbody>
</table>

You can upload a preconfigured dataset if you haven't added any images to a project. The available datasets are based on the project type. To give you more options to experiment, some datasets have labeled images, and some don't.

<img alt="UploadSampleData_Low" />

To add the sample images:

1. Open the project you want to upload images to.
2. Click **Load Sample Data**.
   <img alt="LoadSampleData_0" />
3. Select a dataset.
   <img alt="LoadSampleData_2" />
4. LandingLens uploads the images to your project.


# Access and Use the LandingLens Python Library
Source: https://landinglens.docs.landing.ai/videos/access-and-use-the-landing-ai-sdk-video



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span> (see exceptions below)</td>
    </tr>
  </tbody>
</table>

<iframe title="YouTube video player" />

Watch this video to learn how to access the LandingLens Python library and build an application to detect suits in playing cards.

<Info>The Python library offers limited support for . The Python library can be used to [run inference](https://landing-ai.github.io/landingai-python/inferences/getting-started/) and perform [image operations](https://landing-ai.github.io/landingai-python/image-operations/) like cropping and resizing images. However, it doesn't support other functions for interacting with data on, like uploading images and assigning splits.</Info>


# Agreement-Based Labeling
Source: https://landinglens.docs.landing.ai/videos/agreement-based-labeling-video



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

<iframe title="YouTube video player" />

Agreement-Based Labeling is the concept of allowing multiple users to label the same set of images to analyze the consistency of their labels. This method allows you to identify the areas where users may need more direction with labeling.

To learn more, check out this tutorial video.


# Analyze Model Performance
Source: https://landinglens.docs.landing.ai/videos/analyze-model-performance-video



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

<iframe title="YouTube video player" />

LandingLens offers several tools to help you analyze and understand model performance, including: F1 scores, Precision scores, Recall scores, confusion matrices, and more. Plus, you can view this data at the model level, class level, and evaluation set level.

Use these tools and more to help you improve and iterate on computer vision models in LandingLens!

<Info>Confidence thresholds are only applicable to Object Detection and Segmentation projects.</Info>

<Info>For **Object Detection**, the F1 score combines precision and recall into a single score, creating a unified measure that assesses the model’s effectiveness in minimizing false positives and false negatives. For **Classification**, the F1, Precision, and Recall scores are identical. This is because Classification models have only two prediction outcomes: "Correct" and "Misclassified".</Info>


# Build Anomaly Detection Models
Source: https://landinglens.docs.landing.ai/videos/anomaly-detection-video



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

<iframe title="YouTube video player" />

Use LandingLens to develop [Anomaly Detection](/anomaly-detection) models! The ability to create Anomaly Detection models enables your organization to detect visual deviations and irregularities—with few images of defects upfront.

Whether monitoring quality on a production line, identifying out-of-place items in a warehouse, or flagging visual inconsistencies in your digital workflows, Anomaly Detection helps uncover what doesn’t belong—before it becomes a business issue.

Watch this video tutorial to learn:

* What an Anomaly Detection model is
* How to classify images as Normal or Abnormal at upload
* What images LandingLens uses to train models
* How to use heatmaps to understand model predictions


# Api Key Video
Source: https://landinglens.docs.landing.ai/videos/api-key-video



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✖</span></td>
    </tr>
  </tbody>
</table>

<iframe title="YouTube video player" />

Watch this video to learn how to generate and manage API keys in LandingLens.


# Apply Tags to Images
Source: https://landinglens.docs.landing.ai/videos/apply-tags-to-images-video



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

<iframe title="YouTube video player" />

In LandingLens, you can apply tags to images. This lets you quickly perform an action, like creating labeling tasks or splits.

To learn more, check out this tutorial video.


# Artificial Intelligence and Computer Vision
Source: https://landinglens.docs.landing.ai/videos/artificial-intelligence-and-computer-vision-video



<iframe title="YouTube video player" />

You've probably heard of artificial intelligence (AI) and computer vision (CV), but have you ever wondered what these concepts are and how they work together? Check out this video to learn more.


# Assign a GPU to an Inspection Point
Source: https://landinglens.docs.landing.ai/videos/assign-a-gpu-to-an-inspection-point



<iframe title="YouTube video player" />

You can assign a graphics processing unit (GPU) to an inspection point in LandingEdge. Running an inspection point on a GPU is faster than running on a central processing unit (CPU). Check out this tutorial video to learn how to assign a specific GPU to an inspection point in LandingEdge.


# Compare Model Performance
Source: https://landinglens.docs.landing.ai/videos/compare-models-video



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

<iframe title="YouTube video player" />

In LandingLens, you can quickly and easily compare model performance across multiple datasets in a single project. You can also see how the same model—but with different confidence scores—performs on the same datasets.

There is no one-size-fits-all solution, but quickly comparing model performance can help you identify:

* what model works best for your use case.
* what models might need better images or labels.

To learn more, check out this tutorial video.


# Configure Inspection Points Using Folder Watcher
Source: https://landinglens.docs.landing.ai/videos/configure-inspection-points-using-folder-watcher



<iframe title="YouTube video player" />

Did you know you can run inference in LandingEdge by dragging and dropping images to a folder? This is just one of the many options for running inference in LandingEdge. Check out this tutorial video to find out how.


# Continuous Learning after Model Deployment
Source: https://landinglens.docs.landing.ai/videos/continuous-learning-after-model-deployment-video



<iframe title="YouTube video player" />

Learn how to improve your vision model’s performance in LandingLens by integrating human judgment into the machine learning workflow. Discover how to review predictions, prioritize critical errors, and use expert feedback to drive continuous improvement and refine your model.


# Continuous Learning across LandingEdge and LandingLens
Source: https://landinglens.docs.landing.ai/videos/continuous-learning-video



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

<iframe title="YouTube video player" />

See how to apply the concept of continuous learning when working with LandingLens and LandingEdge. Mark images that have been sent for inference correct or incorrect with human judgement. Then use the incorrect images to improve your model.

You can automatically add images that you've run inference on using LandingEdge into your dataset in LandingLens, and then retrain your model with that new data.

This process of continuous learning ensures that your model and process evolve when you need them to.


# Create New Projects Based On Datasets Video
Source: https://landinglens.docs.landing.ai/videos/create-new-projects-based-on-datasets-video



<iframe title="YouTube video player" />

Did you know LandingLens offers a feature that lets you create a new project by copying an existing dataset? This is useful so you can make changes to the copy without altering the original data. Check out this video to learn more.


# Create New Projects from Snapshots
Source: https://landinglens.docs.landing.ai/videos/create-new-projects-from-snapshots



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

<iframe title="YouTube video player" />

In LandingLens, you can create a new project by copying a snapshot. This is useful so you can change the copy without altering the original data.

To learn more, check out this tutorial video.


# Create Dataset Snapshots
Source: https://landinglens.docs.landing.ai/videos/create-snapshots-video



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

<iframe title="YouTube video player" />

You can create a snapshot of some or all of the images in your project at any time. A snapshot includes the selected images and their labels, metadata, tags, and labeling tasks. With snapshots, you can quickly perform actions, like training a model using only the snapshot or creating new projects from it.

To learn more, check out this tutorial video.


# Creating Streamlit Apps for Visual AI
Source: https://landinglens.docs.landing.ai/videos/creating-streamlit-apps-for-visual-ai-video



<iframe title="YouTube video player" />

Unlock the full potential of LandingLens and Snowflake by building custom, secure Streamlit apps for image review, MLOps, dashboards and other applications.  Learn how to integrate image inference data with structured datasets, build interactive applications, and drive continuous model improvement.


# Curate High Quality Datasets
Source: https://landinglens.docs.landing.ai/videos/curate-datasets-video



<iframe title="YouTube video player" />

The success of a deep learning model for vision tasks starts with the right dataset. In this video, we explore how to curate an optimal, high-quality dataset that aligns with your specific machine learning task. By the end of this video, you'll have a clear strategy for selecting images that improve model performance while avoiding common dataset pitfalls.


# Deactivate Member Accounts
Source: https://landinglens.docs.landing.ai/videos/deactivate-member-accounts-video



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✖</span></td>
    </tr>
  </tbody>
</table>

<iframe title="YouTube video player" />

Learn how to deactivate a user's account in LandingLens. It's best practice to deactivate a user if they no longer work for your organization.


# Download LandingEdge Diagnostics
Source: https://landinglens.docs.landing.ai/videos/download-landingedge-diagnostics-video



<iframe title="YouTube video player" />

If you encounter any unexpected bugs or issues with LandingEdge, we might ask you to send us a diagnostics file. Watch this video to learn how to download this the diagnostics file from LandingEdge.


# Download LandingEdge
Source: https://landinglens.docs.landing.ai/videos/download-landingedge-video



<iframe title="YouTube video player" />

Watch this video to learn how to download [LandingEdge](/landingedge/landingedge-overview).


# Enhance Image Contrast to Make Labeling Easier
Source: https://landinglens.docs.landing.ai/videos/enhance-image-contrast-to-make-labeling-easier



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

<iframe title="YouTube video player" />

Object Detection and Segmentation projects have built-in tools to assist with labeling images that have poor contrast. Auto-contrast and histogram equalization are especially helpful for low-light and infrared images used in machine learning and computer vision.


# How LandingLens Splits Data for Training
Source: https://landinglens.docs.landing.ai/videos/how-landinglens-splits-data-for-training



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

<iframe title="YouTube video player" />

Having the Train, Dev, and Test sets are an essential part of building any machine learning model. In LandingLens, images are automatically split into these datasets. If you're curious about how the Train, Dev, and Test sets work, then this video is for you!


# How to Choose a Computer Vision Use Case
Source: https://landinglens.docs.landing.ai/videos/how-to-choose-a-computer-vision-use-case-video



<iframe title="YouTube video player" />

Learn how to choose use cases for your next computer vision project.


# Improve Model Performance
Source: https://landinglens.docs.landing.ai/videos/improve-model-performance-video



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

<iframe title="YouTube video player" />

Let’s say you recently trained your model and analyzed its performance. Your model isn’t performing as well as you’d like, so you want to improve its performance. LandingLens offers several methods to help improve the performance of your model. This tutorial video explores eight techniques to achieve this goal.


# Install the LandingAI Docker Image
Source: https://landinglens.docs.landing.ai/videos/install-the-landing-ai-docker-image-video



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

<iframe title="YouTube video player" />

&#x20;offers a feature to deploy LandingLens models using Docker. To deploy models using Docker, first, you need to install the  image.

Watch this video to learn how to download the  Docker image.


# Invite Members to LandingLens
Source: https://landinglens.docs.landing.ai/videos/invite-members-to-landinglens-video



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✖</span></td>
    </tr>
  </tbody>
</table>

<iframe title="YouTube video player" />

Watch this video to learn how to invite users to your instance of LandingLens.


# Label Images for Object Detection Projects
Source: https://landinglens.docs.landing.ai/videos/label-images-for-object-detection-projects-video



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

<iframe title="YouTube video player" />

Learn how to label images using bounding boxes, and see how you can use the various Object Detection settings to label precisely.


# LandingLens Demo with Benchmarks | Retinopathy of Prematurity
Source: https://landinglens.docs.landing.ai/videos/landinglens-demo-retinopathy



<iframe title="YouTube video player" />

This video demonstrates how to use LandingLens to train a computer vision model for a multiclass classification project using an open-access retinopathy of prematurity dataset.

It covers the end-to-end process, including data preparation, model training with custom augmentations, performance evaluation, and deploying the model for API-based inference.

LandingLens achieves a F1 score of 92 on the test set as compared to 83 published by the original authors that provided the data.

Original paper with links to download the dataset: [https://www.nature.com/articles/s41597-024-03362-5](https://www.nature.com/articles/s41597-024-03362-5)

Citation:

Zhao, X., Chen, S., Zhang, S. et al. A fundus image dataset for intelligent retinopathy of prematurity system. Sci Data 11, 543 (2024). [https://www.nature.com/articles/s41597-024-03362-5](https://www.nature.com/articles/s41597-024-03362-5)


# Detect Bird Nests on Transmission Towers with LandingLens
Source: https://landinglens.docs.landing.ai/videos/landinglens-detect-bird-nests



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

<iframe title="YouTube video player" />

Detecting bird nests on transmission lines is a critical task for utilities, as these nests can pose significant risks to the safety and reliability of the electrical grid. Traditional methods of manual inspection are time-consuming, labor-intensive, and often hazardous.

LandingLens from LandingAI makes it super easy for utilities to leverage computer vision and machine learning to automate the detection of bird nests. This product demonstration shows how a non-technical user can develop a visual AI solution in as little as an afternoon.


# LandingLens on Snowflake Intro
Source: https://landinglens.docs.landing.ai/videos/landinglens-on-snowflake-intro



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✖</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

<iframe title="YouTube video player" />

Get the most of your data by using LandingLens on Snowflake. Leverage a Snowflake environment to maintain data governance adopt computer vision without moving data. Streamline vision tasks and scale your solution across your organization.


# Landinglens On Snowflake Videos
Source: https://landinglens.docs.landing.ai/videos/landinglens-on-snowflake-videos



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✖</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

<iframe title="YouTube video player" />

&#x20;is a native Snowflake application. LandingLens empowers users to create and train Visual AI models quickly. Watch this overview video to see how it works. The LandingLens Visual AI Platform guides you through the process of uploading images, labeling them, training models, comparing model performance, and deploying models.


# LandingLens Workflow
Source: https://landinglens.docs.landing.ai/videos/landinglens-workflow-2



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

<iframe title="YouTube video player" />

Learn how to use LandingLens directly from Andrew Ng, the Founder of LandingAI! In this video, Andrew Ng walks you through the process of creating a computer vision model in LandingLens. He explains how to upload images, train a model, and test it on new images it has never seen before!


# Launch a Docker Instance
Source: https://landinglens.docs.landing.ai/videos/launch-a-docker-instance-video



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

<iframe title="YouTube video player" />

&#x20;offers a feature to deploy LandingLens models using Docker, enabling DevOps users to manage model inference programmatically.

Watch this video to learn how to launch a Docker instance.


# Limit Access to Projects
Source: https://landinglens.docs.landing.ai/videos/limit-access-to-projects-video



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

<iframe title="YouTube video player" />

When you create a project in LandingLens, it is visible to all users in your instance of LandingLens. You can make projects private anytime and invite only specific members to access them.

To learn more, check out this tutorial video.


# Make Model Predictions
Source: https://landinglens.docs.landing.ai/videos/make-model-predictions-video



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span> (see exceptions below)</td>
    </tr>
  </tbody>
</table>

<iframe title="YouTube video player" />

LandingLens has a built-in feature that lets you test how a trained model might behave in an actual deployment.

To learn more, check out this tutorial video.

<Info>The "Predict" button has been changed to "Try Model". The Deploy page also offers this tool.</Info>

<Info>The video mentions uploading images via a webcam. Uploading images via webcam isn't available when using .</Info>


# Manage Data Augmentations
Source: https://landinglens.docs.landing.ai/videos/manage-data-augmentations-video



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

<iframe title="YouTube video player" />

In LandingLens, the Custom Training process lets you customize certain training settings, including data augmentations. An augmentation applies changes to your images—like increasing brightness and adding blurs—before the model trains on the images. This increases the variations of your images, which allows the model to "prepare" for more situations, like changes in lighting.

To learn more, check out this tutorial video.


# Manage Data Transforms: Rescale, Resize, & Crop
Source: https://landinglens.docs.landing.ai/videos/manage-data-transforms-rescale-resize-crop-video



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

<iframe title="YouTube video player" />

In LandingLens, the Custom Training process lets you customize certain training settings, including data transforms. Transforms let you rescale, resize, and crop all the images in your dataset before model training starts. Transform settings are also applied to images before running inference with the model that Custom Training generates.

To learn more, check out this tutorial video.


# Manage Label Books
Source: https://landinglens.docs.landing.ai/videos/manage-label-books-video



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

<iframe title="YouTube video player" />

Create a Label Book in LandingLens to ensure that Classes are labeled consistently. A Label Book is a living document that allows you to define how to label various categories of Classes clearly.

To learn more, check out this tutorial video.


# Mobile Inference
Source: https://landinglens.docs.landing.ai/videos/mobile-inference-video



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✖</span></td>
    </tr>
  </tbody>
</table>

<iframe title="YouTube video player" />

Watch this video to learn how to run inference using images from your mobile device.


# Model Inference with SQL
Source: https://landinglens.docs.landing.ai/videos/model-inference-with-sql



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✖</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

<iframe title="YouTube video player" />

Learn how to run LandingLens model inferences directly in Snowflake using SQL. Use the `core.run_inferences()` function to perform both batch and single-image inference on your datasets. Then insert the inferences as structured data into a new Snowflake table.


# Evaluate Model Performance | LandingLens on Snowflake
Source: https://landinglens.docs.landing.ai/videos/model-performance-snowflake-video



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✖</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

<iframe title="YouTube video player" />

In this tutorial video, discover four ways of evaluating the performance of a Classification computer vision model in :

1. Model metrics such as F1, Precision and Recall
2. Confusion matrix, confidence scores and visual inspection of misclassifications
3. Heatmap overlays on image pixels
4. Evaluations sets and side-by-side comparisons


# Parallel Training
Source: https://landinglens.docs.landing.ai/videos/parallel-training



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

<iframe title="YouTube video player" />

LandingLens offers parallel training, which means when one model is training, you can start training another model. This is helpful if you want to compare performance between multiple datasets or model training settings.

To learn more, check out this tutorial video.


# Port Conflicts And Changing Port Number
Source: https://landinglens.docs.landing.ai/videos/port-conflicts-and-changing-port-number



<Info>This article is only applicable to LandingEdge v1.</Info>
Some users may encounter a port conflict error when installing LandingEdge v1. If you encounter this error, follow the instructions below.

1. Navigate to the directory path in the error message, which is: **C:\Users\<user-name>.clrt\app\_data**.
2. Find a file named **ports.json** in the directory and open it with a text editor application.
3. Identify an empty port on your computer.
4. In the **ports.json** file, change **ui\_port** to the empty port you just identified.
5. Save your changes and return to installation procedure.


# Refer to Heat Maps for Classification Models
Source: https://landinglens.docs.landing.ai/videos/refer-to-heat-maps-for-classification-models



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

<iframe title="YouTube video player" />

Have you ever wondered what specific characteristics models consider when they’re making predictions? For Classification projects, you can view a heat map to see just that.

To learn more, check out this tutorial video.


# Retrain after Adding More Classes in LandingLens
Source: https://landinglens.docs.landing.ai/videos/retrain-after-adding-more-classes



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

<iframe title="YouTube video player" />

When a model encounters something new, it may be time to retrain. This video shows how a model in production is confused by an object it has not seen before - horses. In LandingLens it is easy to create a new class, label a small number of images and retrain the model to detect the new class.


# Revert Projects from a Snapshot
Source: https://landinglens.docs.landing.ai/videos/revert-projects-from-a-snapshot



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

<iframe title="YouTube video player" />

In LandingLens, you can revert projects you own from a Snapshot. This is useful if you saved a snapshot, added images and labels to it, then decided the new images are no longer relevant to your project, so you want to return to the first dataset. You can do this by reverting to the snapshot you saved.

To learn more, check out this tutorial video.


# Revert To A Saved Dataset Video
Source: https://landinglens.docs.landing.ai/videos/revert-to-a-saved-dataset-video



<iframe title="YouTube video player" />

If you are the project owner in LandingLens, you can revert your project to use one of the saved datasets. For example, let's say that you saved a model and later added more images and labels. After training the model a second time, you see that the first model performed better, so you want to go back to that dataset. You can do this by reverting the dataset. Take a look at how to revert to a saved dataset by watching this tutorial video.


# Roles and Permissions in LandingEdge
Source: https://landinglens.docs.landing.ai/videos/roles-and-permissions-in-landingedge-video



<iframe title="YouTube video player" />

LandingEdge offers roles to limit who can access different parts of the application. This is useful if LandingEdge is deployed to a shared machine and you want to prevent users from accidentally stopping or changing an inspection point. Check out this tutorial video to learn more about how to manage these roles.


# Run Inference on Videos in LandingEdge
Source: https://landinglens.docs.landing.ai/videos/run-inference-on-videos-in-landingedge-video



<iframe title="YouTube video player" />

Did you know you can run inference in LandingEdge by pulling frames (stills) from a video? This is just one of the many options for running inference in LandingEdge. Check out this tutorial video to find out how.


# Run Inference with Web APIs in LandingEdge
Source: https://landinglens.docs.landing.ai/videos/run-inference-with-web-apis-in-landingedge



<iframe title="YouTube video player" />

Did you know you can run inference in LandingEdge by calling an API? This is just one of the many options for running inference in LandingEdge. Check out this tutorial video to find out how.


# Run Parallel Training in Custom Training
Source: https://landinglens.docs.landing.ai/videos/run-parallel-training-in-custom-training



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

<iframe title="YouTube video player" />

LandingLens offers parallel training for Custom Training! Parallel training is the process of training multiple models simultaneously. This is helpful if you want to compare performance between model training settings.

The Custom Training process is designed for users familiar with machine learning concepts and understand how the different settings impact the resulting model.

To learn more, check out this tutorial video.


# Ingest Images with Snowflake Sync
Source: https://landinglens.docs.landing.ai/videos/snowflake-sync-video



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✖</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

<iframe title="YouTube video player" />

Bring images into a Snowflake stage and sync the contents with . This tutorial uses pre-labeled images for a binary classification project. It shows how to create the stage in Snowsight and how to grant the required permissions for the image sync to succeed.


# Split Images into the Train, Dev, and Test Sets
Source: https://landinglens.docs.landing.ai/videos/split-images-into-the-train-dev-and-test-sets-video



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

<iframe title="YouTube video player" />

LandingLens automatically splits images into the Train, Dev, and Test sets during model training. However, if you want to split images into datasets manually, LandingLens offers multiple ways to do this. Watch this tutorial video to learn more!

<Info>If you're unfamiliar with the concept of Splits, check out [this video](./how-landinglens-splits-data-for-training) to learn more.</Info>


# Train Models Based on a Snapshot
Source: https://landinglens.docs.landing.ai/videos/train-models-based-on-a-snapshot-video



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

<iframe title="YouTube video player" />

In LandingLens, you can train a model based on the data in a snapshot. This allows you to generate multiple models on different datasets in a single project. When you train a model this way, you will use Custom Training.

To learn more, check out this tutorial video.


# Configure and Run Model Training Jobs in LandingLens on Snowflake
Source: https://landinglens.docs.landing.ai/videos/train-models-snowflake-video



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✖</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

<iframe title="YouTube video player" />

In this video tutorial, you will see how to configure four computer vision models and begin model training jobs in . Learn about data partitioning, GPU provisioning, and model training configurations. Monitor training progress through loss charts.


# Train Models
Source: https://landinglens.docs.landing.ai/videos/train-models-video



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

<iframe title="YouTube video player" />

In LandingLens, after you've uploaded and labeled your images, you can train your model. Watch this video to learn how to use the default training method (Fast Training). During Fast Training, LandingLens automatically fine-tunes its settings to optimize speed and model accuracy.


# Understand the Different Project Types
Source: https://landinglens.docs.landing.ai/videos/understand-the-different-project-types-video



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span> (see exceptions below)</td>
    </tr>
  </tbody>
</table>

<iframe title="YouTube video player" />

LandingLens offers the ability to create the following computer vision model types: Object Detection, Segmentation, Classification, and Visual Prompting. Learn about each one in this video.

<Info> is not available in .</Info>


# Classify Images at Upload in LandingLens
Source: https://landinglens.docs.landing.ai/videos/upload-and-label-images-for-classification-projects-video



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

<iframe title="YouTube video player" />

There are several ways to upload images into LandingLens, the Visual AI platform from LandingAI. Watch this video to learn how to classify (label) images at upload in a Classification project.

If you have LandingLens on Snowflake, you can also classify images when loading them from a Snowflake stage. To learn how to do that, check out [Ingest Images with Snowflake Sync](./snowflake-sync-video).

<Info>Users of  can also classify images when uploading them from Snowflake stages. For more information, go to [Load Images from Snowflake into LandingLens](/load-images-from-snowflake).</Info>


# Upload Images from a Smartphone to LandingLens
Source: https://landinglens.docs.landing.ai/videos/upload-images-from-a-smartphone-to-landinglens-video



<iframe title="YouTube video player" />

There are several ways to upload images into LandingLens, the Visual AI platform from LandingAI. Watch this video to learn how to [upload images from a smartphone](/upload-images-phone) directly into a LandingLens project.


# Upload Images from a Webcam
Source: https://landinglens.docs.landing.ai/videos/upload-images-from-a-webcam-video



<iframe title="YouTube video player" />

There are several ways to upload images into LandingLens, the Visual AI platform from LandingAI. Watch this video to learn how to [upload images from a webcam](/upload-images-webcam) directly into a LandingLens project.


# Upload Images
Source: https://landinglens.docs.landing.ai/videos/upload-images-video



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span> (see exceptions below)</td>
    </tr>
  </tbody>
</table>

<iframe title="YouTube video player" />

There are several ways to upload images into LandingLens, the Visual AI platform from LandingAI. You can easily drag and drop files and upload images from your smartphone. Already have a labeled dataset? You can even import that!

This video gives you an overview of all the methods for uploading images into LandingLens projects. After this, you’ll be able to choose the upload method that works best for your use case.

<Info>Some upload methods aren't available when using .</Info>


# Upload Labeled Images to Object Detection Projects
Source: https://landinglens.docs.landing.ai/videos/upload-pre-labeled-images-to-object-detection-projects



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

<iframe title="YouTube video player" />

There are several ways to upload images into LandingLens, the Visual AI platform from LandingAI. Watch this video to learn how to upload a labeled Object Detection dataset into a LandingLens project.

LandingLens supports uploading labeled Object Detection datasets in the Pascal VOC format. We provide [Helper Scripts](https://github.com/landing-ai/helper-scripts/tree/main) to convert COCO and YOLO datasets to Pascal VOC.


# Upload Labeled Images to Segmentation Projects
Source: https://landinglens.docs.landing.ai/videos/upload-pre-labeled-images-to-segmentation-projects-video



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

<iframe title="YouTube video player" />

There are several ways to upload images into LandingLens, the Visual AI platform from LandingAI. Watch this video to learn how to [upload a labeled Segmentation dataset](/upload-labeled-images-seg) into a LandingLens project.

LandingLens supports uploading labeled Segmentation datasets with images, Segmentation Masks, and Defect Maps (also called Class Maps). We provide [Helper Scripts](https://github.com/landing-ai/helper-scripts/tree/main) to convert COCO datasets to the supported format.

To learn more, check out this tutorial video.


# Use Smart Labeling to Label Images in Segmentation Projects
Source: https://landinglens.docs.landing.ai/videos/use-smart-labeling-to-label-images-in-segmentation-projects-video



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✖</span></td>
    </tr>
  </tbody>
</table>

<iframe title="YouTube video player" />

Learn how to boost efficiency in Segmentation projects by labeling images faster with Smart Labeling.


# Visual Prompting
Source: https://landinglens.docs.landing.ai/videos/visual-prompting-video



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✖</span></td>
    </tr>
  </tbody>
</table>

<iframe title="YouTube video player" />

Watch this video to learn how to build a deployable model using Visual Prompting.


# Why Use a Cloud Platform for Computer Vision?
Source: https://landinglens.docs.landing.ai/videos/why-use-a-cloud-platform-for-computer-vision-video



<iframe title="YouTube video player" />

Learn the benefits of using a cloud platform for your computer vision models.


# View Member Statuses
Source: https://landinglens.docs.landing.ai/view-members



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✖</span></td>
    </tr>
  </tbody>
</table>

Members are managed on the **Members** page. To access this page, click the **User Menu** and select **Members** from the drop-down menu.

<img alt="Members in the User Menu" />

## Member Account Statuses

Each member account has a status that shows the state of the account. These are the different statuses:

* **Active**: The account has been registered, and the user can access LandingLens.
* **Pending**: The account has not yet been registered, and the user cannot access LandingLens. The user must complete their registration to access LandingLens.
* **Inactive**: The account has been deactivated, and the user cannot access LandingLens. Their account must be [reactivated](./deactivate-member-accounts) to access LandingLens again.

<img alt="Member Statuses" />


# View Predictions
Source: https://landinglens.docs.landing.ai/view-predictions



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span> (see exceptions below)</td>
    </tr>
  </tbody>
</table>

After training a model, you can see the model's predictions as overlays on the images in your dataset. The overlay format depends on the project type:

* **Object Detection**: Predictions are dotted bounding boxes that are the color of the class the model predicted.
* **Segmentation**: Predictions are highlights that are the color of the class the model predicted.
* **Classification and Anomaly Detection**: The predicted class name displays in the bottom left corner of the image. A green check mark means the prediction matches the label. A red "x" means the prediction doesn't match the label.

<Info>The information in this section is not applicable to Visual Prompting.</Info>

## Use Prediction Overlays to Help You Troubleshoot

The predictions give you a visual indication of how your model performed. If the predictions are on top of or close to the labels, then the model performed well. If there's a discrepancy between the label and prediction, find out the root cause; resolving it will likely improve model performance.

For example, in the image below, there's a blue prediction over a yellow label. This could indicate that the object was mislabeled or that the model needs more labeled images of both classes to correctly detect them.

<img alt="prediction_doesnt_match_ground" />

## View Predictions for the Dataset

You can see a model's predictions for images in the Build tab. You can also change the applied model and its [confidence threshold](./view-predictions#confidence-threshold) (for Object Detection and Segmentation) or [anomaly threshold](./view-predictions#anomaly-threshold) (for Anomaly Detection).

To do this:

1. Open the project to the Build tab.
2. Turn on the **Prediction** toggle.
3. By default, the most recently used or trained model is applied. If you want to select a different model or adjust the threshold, click the model name.
   <img alt="PredictionToggle_1" />
4. Select the model you want to apply to the dataset from the **Model** drop-down menu. Models are listed in the chronological order in which they were created.
5. (Optional) Adjust the [Confidence Threshold](./view-predictions#confidence-threshold) slider (for Object Detection and Segmentation) or the [Anomaly Threshold](./view-predictions#anomaly-threshold) slider (for Anomaly Detection).
   <img alt="PredictionToggle_2" />
6. To close the Prediction menu, click anywhere off of the menu.

<Info>Curious why some images do or don't have predictions? Get the answers here:<br />- [Why Do Some Images Not Have Predictions?](#why-do-some-images-not-have-predictions%3F)<br />- [When Does a Model Make Predictions?](#when-does-a-model-make-predictions%3F)</Info>

## Confidence Threshold

The *confidence score* indicates how confident the model is that its prediction is correct.

The *confidence threshold* is the minimum confidence score the model must assign to a prediction in order for it to believe that its prediction is correct. Typically, a lower confidence threshold means that you will see more predictions, while a higher confidence threshold means you will see fewer.

When LandingLens creates a model, it selects the confidence threshold with the best F1 score for all labeled data.

Confidence thresholds are only applicable to Object Detection and Segmentation projects.

## Anomaly Threshold

Anomaly Detection models have an *anomaly threshold*, which determines if an image is classified as Normal or Abnormal.

Each pixel in the image has an abnormality score. If any pixel's score exceeds the anomaly threshold, the image is classified as Abnormal.

Let's take a look at the screenshot below as an example. The Anomaly Threshold is set to 27%. If any pixel in an image has an abnormality score higher than 27%, the model will classify the image as Abnormal.

<img alt="ViewPredictions_AnomalyThreshold" />

### Set the Anomaly Threshold to Minimize Missed Defects

Adjust the **Anomaly Threshold** to a value that correctly identifies all Abnormal images—even if it means incorrectly predicting some Normal images.

This approach helps ensure you don’t miss any true anomalies, which is often more critical than avoiding false positives.

For example, imagine you're inspecting pills for defects. If the threshold is set too low, the system might miss some defective pills and classify them as Normal—potentially allowing flawed products to reach customers. On the other hand, a higher threshold increases the chance of catching all defective pills, even if some Normal pills are mistakenly flagged. These false positives can be reviewed manually to prevent unnecessary waste or delays.

To achieve the best results, experiment with the Anomaly Threshold until you find a value that reliably detects all Abnormal images, accepting a small number of false positives as a trade-off.

## Images vs. Instances (Object Detection)

For Object Detection projects, when the Prediction toggle is on, you can choose to view predictions by *image* or by *instance*. These are controlled by the **Images** and **Instances** buttons on the Build tab.

### Images View

When you select **Images**, all the images in the dataset display. This is the default view.

<img alt="predictions_images" />

<Info>To see the predictions more clearly, turn off the **Ground Truth** toggle.</Info>

### Instances View

When you select **Instances**, each labeled or predicted area displays as a separate image. You can think of this as LandingLens displaying "one instance" of a label or prediction at a time. You can filter the instances by **Ground truth** (the label) or **Prediction**. The images are zoomed in to help you see the object. Instances view is helpful if the objects of interest are too small to see when viewing the dataset in Images view.

<img alt="predictions_instances" />

Select the **Prediction** radio button in Instances view to filter by model predictions. The predictions overlay includes the **confidence score**, which represents how certain (or "confident") the model is that its prediction is accurate. For example, in the screenshot below, the model is 39% confident that the prediction on the left is a Scratch.

<img alt="predictions_instances_pred" />

<Info>When Prediction is enabled in Instances view, instances are sorted by default from lowest confidence score to highest. Use the **Sort** feature if you want to use different sorting criteria.</Info>

## View Predictions for Each Image

Click an image to open it and see the model's predictions. You can toggle the **Labels** and **Predictions** on and off. To learn how to turn predictions into labels, go to [Label Assist](./label-assist).

<img alt="predictions_onImage" />

## Why Do Some Images Not Have Predictions?

Some images in a dataset may not have predictions. In these situations, it's because the model did not have an opportunity to make predictions on those images. For example, if [Predict at Upload](./plans#predict-at-upload) is disabled and you upload an image after training a model, the model doesn't have an opportunity to make a prediction on that image. (Predict at upload is not available in .)

<img alt="no_prediction" />

## When Does a Model Make Predictions?

When you train a model, the model makes predictions for the images currently in the dataset. But there are other situations that also trigger a model to make predictions on an image. Here is a list of all situations that cause a model to make predictions on an image:

* When you train a model, the model makes predictions on all images currently in the dataset.
* If [Predict at Upload](./plans#predict-at-upload) is enabled and you upload an image after training a model, the model makes a prediction on the image. (Predict at upload is not available in .)
  <img alt="PredictAtUpload_June2024" />
* If you go to the **Models** page and run a model on an [evaluation set](./models-page#add-evaluation-sets-and-run-models-on-them), the model checks what images it hasn't "seen" before. If the model hasn't "seen" the image before, it makes a prediction on it. You can then view those predictions when you select that model on the Build tab.
  <img alt="predictions_evalset" />
* If you open an image and click **Get Prediction**, the selected model makes a prediction on the image.
  <img alt="getPrediction" />

## How Does LandingLens Determine if a Prediction Matches the Ground Truth? (Object Detection)

For Object Detection models, LandingLens uses the Jaccard index with a threshold of 0.2 to determine if a ground truth label matches a model's prediction. This means that if the overlap between the ground truth and the prediction is 20% or higher, the prediction is considered a match.

The Jaccard index, often called Intersection over Union (IoU), is a metric used to measure the similarity between two sets. In Object Detection, it’s applied to compare the area of overlap between a predicted bounding box and the ground truth box against the total area covered by both boxes (their union). Mathematically, the Jaccard index is expressed as:

$$
\frac{\text{Area of Overlap}}{\text{Area of Union}}
$$


# Search for Projects
Source: https://landinglens.docs.landing.ai/view-projects



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✓</span></td>
    </tr>
  </tbody>
</table>

## View the Most Recently Opened Projects

To view the last three projects recently opened by anyone in your Organization, click the **logo** in the top left corner.

To see all projects, click  **View All** or **Projects**.

<img alt="ViewProjects_Home_2" />

## View All Projects

To view all projects in your Organization, click **Projects** at the top of the page

<img alt="ViewProjects_All_2" />

## Search for Projects

Click **Projects** at the top of the page. Enter the project name, type, or creator in the search bar. To narrow down results, click the project type.

<img alt="Projects_search_type" />

To change how projects are sorted, click **Last Opened** and select a sort option.

<img alt="projects_sort" />

## Project Card Information and Actions

Each project card on the Projects page has the information and actions described in the following table. Icons are described from left to right, top to bottom.

| Icon | Description                                                                                                                                        |
| ---- | -------------------------------------------------------------------------------------------------------------------------------------------------- |
|      | Icon for the project type. Hover over the icon to see the project type name.                                                                       |
|      | Project name.                                                                                                                                      |
|      | Actions icon. Click to **Rename** or **Delete** a project.<br /><br />If the project is private, you can also **Invite Teammates** to the project. |
|      | Icon that indicates if the project is public (people icon) or private (lock icon)                                                                  |
|      | First name of the user who created the project. Hover over the icon to see the user's full name and email address.                                 |
|      | Number of images in the project. Hover over the icon to see the number of labeled images.                                                          |
|      | Number of models in the project.                                                                                                                   |


# Visual Prompting
Source: https://landinglens.docs.landing.ai/visual-prompting



*This article applies to these versions of LandingLens:*

<table>
  <thead>
    <tr>
      <th>LandingLens</th>
      <th>LandingLens on Snowflake</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td><span>✓</span></td>
      <td><span>✖</span></td>
    </tr>
  </tbody>
</table>

<iframe title="YouTube video player" />

&#x20;is a paradigm shift in the field of computer vision. You label only a few small areas of an object in a few images, and the model almost immediately detects the whole object in all of your images. In most cases, the model’s predictions aren’t 100% accurate the first time around, but you can easily label a few more small areas, re-run the model, and check your results.

&#x20;is a highly accurate and fast model that enables you to quickly create and deploy your own custom computer vision model.

Because of its speed and ease of use, we encourage you to try  before creating any other project type.

<img alt="Pandas" />

<Info>Visual Prompting is in Beta. It might not function as well as our other production-ready features.</Info>

## What does the phrase “” mean?

In the field of artificial intelligence (AI), *prompting* refers to providing input to an AI model for that model to generate a response. It's like prompting a person to answer a question, or giving a student a prompt to write an essay about.

You might have already heard about AI prompting without realizing what it was called. For example, the popular chatbot ChatGPT relies on prompting: you ask ChatGPT a question or tell it to describe something, and the Model responds. The application DALL-E is similar: you describe what you want to see, and the Model generates a digital image based on your description.

Both of these types of applications rely on *textual* prompts; you need to write a sentence or series of words for the AI Model to work. ChatGPT has a text-to-text workflow, and DALL-E has a text-to-image workflow.

Now, with the release of ,  has introduced an *image-to-image* AI prompting workflow. You give a visual prompt to the  model, and it provides a visual output. In practice, you label a small section of an object in an image, and  model is able to detect the whole object you marked, not just in the original image, but in others too.

&#x20;is the next step in broadening the applications of AI prompting.

<Info> is not associated with ChatGPT or DALL-E.</Info>

## &#x20;Workflow

The  workflow is an iterative process. After you label your first image, run your model. When you see the results, fine-tune your labels and re-run the model. It is normal for this process of re-labeling and re-running to occur a few times before your model is ready to be deployed.

&#x20;models run quickly, so even though this is an iterative process, you will be able to deploy even complex models in minutes.

Here's an overview of the  workflow:

1. [Upload](./upload-images) images
2. [Label](./visual-prompting#label-images) small portions of an image. Use at least two classes.
3. Click [Run](./visual-prompting#run-the-model-review-predictions-and-iterate-your-labels)**.**
4. [Review](./visual-prompting#run-the-model-review-predictions-and-iterate-your-labels) the predictions of that image.
5. If the results aren't quite right yet, fine-tune your labeling and run the model again. Repeat until you're happy with the results.
6. [Deploy](./visual-prompting#deploy-your-variableil-model) the model.

## Label Images

If you've created computer vision projects before, you'll immediately notice that labeling images with  is drastically different—and easier and cooler—than with those other projects. Because of the powerful and intuitive algorithms built into , you only need to label a few small areas to get lightning-fast accurate results.

<Info> Projects support a maximum of 25 images.</Info>

### Accurately Label Small Areas

&#x20;introduces a fast new way to label images called Prompting. **Prompting** is the act of only labeling a small area of the object you want to identify. Your model learns from each pixel you label, so it's important that your labels are precise.

Say you build a model to detect birds. Take a look at the image below. There are two classes labeled: Bird (purple) and Background (yellow). Do you notice anything wrong? If you look closely, you can see that the Bird class is not labeled precisely because the purple line stretches into the background. The model will think that portions of the background belong to the Bird class, and it won't be able to accurately detect birds.

<img alt="IL_label_bad" />

Now let's look at the next image. The Eraser tool was used to delete the purple "Bird" label that included the background, so now the label only covers the bird. This labeling is more precise, and will create a more accurate model.

<img alt="IL_label_good_bird" />

It's generally okay if you make a couple of minor mistakes in other project types, like Segmentation or Object Detection. However, if you make a mistake in , the model won't be as forgiving and may show some inaccurate results.

### Label at Least Two Classes

&#x20;Projects require at least two classes. By establishing two classes, the model will be able to "understand" where one class ends and another begins. Even if you only want to detect one specific object, you need to give the class some content to compare itself against. A  model predicts a class for each pixel in an image. So if you had only one class, the whole image would be predicted as belonging to that class. Therefore, you must have at least two classes.

If you only want to detect one object and aren't sure what to name your second class, consider creating a class with one of these names:

* Background
* Environment
* Unimportant
* Not \[object]
* Nothing to Label

For example, let's say you want to detect apples during the manufacturing process. You don't need to detect the machinery, conveyor belt, workers, or anything else. You could set up a  Project that results in the following images. The first image shows the original image. The second shows the image with apples in pink, and all other items in blue. Even though the machinery and conveyor belt look very different from each other, they are both categorized as part of the background.

| <img alt="apple_before(1)" /> | <img alt="apple_after(1)" /> |
| ----------------------------- | ---------------------------- |

### Only Label a Few Images

&#x20;doesn't require many images. We recommend you run the model after adding labels to just one image. Review the Predictions, and relabel that image based on any incorrect predictions. Then run the model again, and view the predictions for a few other images. Label one or two more images, and run the model again. Continue to iterate like this until the predictions are accurate.

#### Use Case: Images Are Similar

If all of your images are of the same objects, with the same backgrounds, in similar conditions (like lighting), then you will need fewer labeled images.

For example, if you're creating a model to detect issues on PCB boards on an assembly line at the same inspection point, you can expect all of the images to be very similar to each other.

<img alt="images_similar" />

#### Use Case: Images Are Very Different

If all of your images are of different objects, with different backgrounds, in different conditions (like lighting), then you will need more labeled images.

For example, if you're creating a model to detect dogs, you will need more images to account for all the different variables. You could upload images of the following:

* Different dog breeds
* Different colored dogs
* Dogs from different angles
* Dogs with collars
* Dogs without collars
* Dogs in different settings
* Dogs in sunny conditions
* Dogs in overcast conditions

<img alt="images_different" />

### Labeling Tools

LandingLens offers you several tools to help you label and navigate images. Refer to the image and table below to learn more about these tools.

<img alt="labeling_tools_4" />| Icon | Tool | Description | Shortcut |
\| --- | --- | --- | --- |
\|  | Zoom | Zoom in and out. | Mouse wheel up: Zoom outMouse wheel down: Zoom in |
\|  | Pan | Click the image and move it. This is especially useful if the image is zoomed in and you want to see part of the image that is out of the frame. | V: Select |
\|  | Brush | "Paint" over an area that you want to identify. | B: Select |
\|  | Eraser | Remove part of a brush stroke. | E: Select |
\|  | Size Slider | Move the slider to change the size of the Brush or Eraser. | ]: Make larger<br />\[: Make smaller |
\|  | Undo | Undo the last action. | Command+Z (Mac)Ctrl+Z (Windows) |
\|  | Redo | Redo the action that you undid. | Shift+Command+Z (Mac)Shift+Ctrl+Z (Windows) |
\|  | Clear All Labels | Remove all labels from the image. | None |
\|  | Labels | View the labels you added. This toggle is only visible after you run the model. | None |
\|  | Prediction | View the predictions from the model. This toggle is only visible after you run the model. | None<br /><br /> |
\|  | Class | Select a class. Any labels added with the Brush are applied to the selected class. | Up arrow key: Select the class aboveDown arrow key: Select the class below |
\|  | Guides | Use the white dotted guides to align the Brush or Eraser with any vertical or horizontal features. (Not marked on the image above.) | None |

### Navigate Images in Labeling View

When you're labeling an image, you can easily see and navigate to the other images in your dataset.

Click the **Browse Images in Sidebar** icon to view the images in your dataset in a bar above the opened image. These images are grouped by whether they are **Labeled** or **Unlabeled**.

<img alt="labeling_tools_1(1)" />

Click the **Previous** and **Next** icons to navigate to other images. Use the **left arrow** and **right arrow** keys as shortcuts.

<img alt="labeling_tools_2(1)" />

## Run the Model, Review Predictions, and Iterate Your Labels

After you've labeled at least two classes, click **Run** at the bottom of the page (or press **Enter**).

<img alt="farmland_label" />

In only a few seconds, the model's predictions overlay on the image.

<img alt="farmland_predictions" />

You can use the **Labels** and **Predictions** toggles to compare the results with your labels. You can also review predictions for all images in your dataset. If some of the predictions aren't completely accurate—and we don't expect them to be after running the model only once—add a few more labels.

Start with labeling a few areas that have incorrect predictions. For example, in the GIF below, an area is incorrectly predicted as House (blue). To correct the model, I label that section as Farmland (purple) and click **Run**. You can see that the model now accurately predicts that area as Farmland (purple).

<img alt="farmland_iterate" />

We recommend you run through this cycle a few times: run the model, review, label, repeat. For many datasets, this process only takes a few minutes.

## Deploy Your  Model

After you're happy with your  model, you are ready to use it! To use a model, you *deploy* it, which means you put the model in a virtual location so that you can upload images to it. When you upload images, the model runs *inferences*, which means it detects what it was trained to look for.

Unlike other project types in LandingLens, you don't need to select a specific model when deploying . This is because you're continuously iterating on the same model, and not creating a new one each time you run the model.

For detailed instructions for how to deploy models, go to [Cloud Deployment](./cloud-deployment).

### Deployment Limitations in Beta

&#x20;is in beta, so we're still ironing out a few kinks. Here are known limitations for this beta release:

* The predictions in the user interface will have more distinct lines around detected objects than the predictions in the deployed model. We're working hard to get the predictions in the deployed model as good as what you see on screen.

* Models from  projects can't be deployed in [LandingEdge](./landingedge/landingedge-overview) or [Docker](./landingedge/docker-deploy).

## Project View

When you're looking at and labeling an image (Labeling View), click **Project** to see all the images in your project.

<img alt="ProjectView_1" />

## Labels and Prediction Toggles

After you've run your model at least once, these toggles display in both the [Labeling View](./visual-prompting#labeling-tools) and [Project View](./visual-prompting#project-view):

* **Labels**: View the labels you added.
  <img alt="toggle_labels" />
* **Prediction**: View the Predictions from the model.
  <img alt="toggle_predictions" />

## &#x20;FAQ

### Is  a form of Segmentation?

Yes!  is a type of semantic segmentation, just like the Segmentation project type. Semantic segmentation is when the model learns from each pixel in an image. For example, say you have an image of New York City. You can label some pixels so the model can identify these classes: people, cars, buildings, billboards, and the sky. Furthermore, each object identified as a class will fall under one entity. In this case, every car detected will simply be labeled as "Car", instead of Honda, Toyota, Mercedes, etc.

So, how does  differ from Segmentation? In short,  only requires partial labeling, while Segmentation requires full labeling.

### Is  going to replace Segmentation?

Not to worry, the Segmentation project type isn't going anywhere and will continue to be available.

### Where is the "Nothing to Label" option?

&#x20;doesn't have a "Nothing to Label" option because the model only takes into consideration labeled pixels.

### Why are there no metrics?

For the other project types in LandingLens, metrics are created by comparing the overlap between your labels (the Ground Truth) and the model's predictions. The metrics tell you how often the model predicted correctly.

Since  only requires you to label small areas of the object you want to detect—and not the full object—the model doesn't have a full Ground Truth to compare itself against. The metrics we use for other project types could be misleading.

### Why can't I fine-tune the hyperparameters?

We've pre-selected hyperparameters to optimize the speed and accuracy of , so that you can focus on labeling data.

### Does  offer Agreement-Based Labeling?

No. Agreement-Based Labeling, which is available for other project types, allows multiple users to label the same set of images to analyze the consistency of their labels. That approach doesn't apply to  because you only need to label a few small areas of an object for the model to learn to detect it. If we used Agreement-Based Labeling in , each user could label a different area of the same object. Even though each label would be different, they could all be correct.

### Why don’t I see Predictions on an image I just uploaded?

If you run the model and later upload a new image, the model doesn’t automatically process that image. You must re-run the model to add a prediction.

### Can I delete or rename classes in Visual Prompting projects?

No, classes cannot be deleted or renamed in Visual Prompting projects.