Export to TF.js Model Format From a YOLO26 Model Format (Deprecated)

@WereUs666 thanks for sharing the details. For pose models in TF.js format, we recommend trying model.export(format='tfjs', imgsz=(640, 640)) with a fixed input size. Note that tfjs is deprecated since Ultralytics 8.4.83 and now exports a LiteRT model, so for new work use format='litert' (see the LiteRT guide). If issues persist, please ensure you're using the latest ultralytics and onnx2tf packages. For commercial deployment needs, visit https://ultralytics.com/license.

@priyalpatel1503 the tensor output you are encountering contains raw predictions, which need decoding to extract bounding box coordinates, class labels, and confidence scores. YOLO models typically output a tensor where each grid cell holds predictions including bounding boxes, objectness scores, and class probabilities. You can apply non-maximum suppression (NMS) and appropriate post-processing on this tensor to interpret the results. Refer to the TensorFlow.js YOLO post-processing example for guidance, as it follows a similar concept.

I have tried implementing your above solution to run inference on an image, but I am encountering an issue where the predictions object is not iterable. Despite following the suggested solutions, it still doesn't work.

Here's the solution I tried: async function runInference() { // Load the model const model = await tf.loadGraphModel('/path/to/yolov8n_web_model/model.json');

// Load and preprocess the image
const img = document.getElementById('input-image');
const tensor = tf.browser.fromPixels(img).expandDims(0).toFloat().div(tf.scalar(255));

// Run inference
const predictions = await model.executeAsync(tensor);

// Process the output tensors
const [boxes, scores, classes] = predictions;
const boxesData = boxes.dataSync();
const scoresData = scores.dataSync();
const classesData = classes.dataSync();

// Filter predictions by confidence threshold
const confidenceThreshold = 0.5;
const validDetections = [];
for (let i = 0; i < scoresData.length; i++) {
    if (scoresData[i] > confidenceThreshold) {
        validDetections.push({
            box: boxesData.slice(i * 4, (i + 1) * 4),
            score: scoresData[i],
            class: classesData[i]
        });
    }
}

// Display results
validDetections.forEach(detection => {
    const [x, y, width, height] = detection.box;
    const score = detection.score;
    const className = detection.class;

    // Draw bounding box and label on the image
    // (Implement your drawing logic here)
});

}

window.onload = runInference; However, when running this code, I am getting the following error:

Error: predictions is not iterable

I have tried several approaches based on your earlier suggestions, but none of them resolved the issue. I am unsure how to correctly extract the bounding boxes, class labels, and confidence scores from the output.

Could you please provide guidance on how to properly handle the output of model.executeAsync(tensor) and how to extract the predictions (bounding boxes, class labels, and scores)?

The error occurs because model.executeAsync(tensor) returns a single tensor or an array of tensors, depending on the model's output structure. In your case, ensure the model's output aligns with your extraction logic. Use predictions.array() or predictions.dataSync() to inspect the raw output structure and adjust your code to handle it correctly. For YOLO models, you may need to decode the tensor output into bounding boxes, classes, and scores using custom logic or post-processing functions.

@glenn-jocher After calling model.executeAsync(tensor), the output I receive is a tensor object with the following shape and details: { "kept": false, "isDisposedInternal": false, "shape": [ 1, 84, 8400 ], "dtype": "float32", "size": 705600, "strides": [ 705600, 8400 ], "dataId": { "id": 864 }, "id": 555, "rankType": "3", "scopeId": 641 }

1. When using predictions.array(), it returns a Promise in TensorFlow.js .The Promise resolves to a nested array structure: [ [Array(8400), Array(8400), ..., Array(8400)] ] (84 arrays, each containing 8400 values).
2. When using predictions.dataSync(), I receive a Float32Array with 705600 values.

I need guidance on how to properly decode and interpret this output, especially in terms of extracting bounding box coordinates, class IDs, and class probabilities. Could you provide advice or code examples for decoding these predictions, particularly for the YOLOv8 model in TensorFlow.js? Any references, examples, or explanations will be helpful.

To decode the YOLOv8 TensorFlow.js output, you need to understand that the tensor contains raw predictions. The shape [1, 84, 8400] represents [batch_size, num_features, num_predictions_per_feature]. Here's a breakdown of processing it:

1. Use predictions.array() to resolve the tensor into a nested array structure.
2. The 84 features are the bounding box (x, y, w, h) followed by 80 class scores. YOLOv8 has no separate objectness score:
   • The first 4 values are the bounding box coordinates.
   • The remaining 80 values (indices 4–83) are the per-class scores.
3. For each prediction:
   • Scale the bounding box coordinates to your image size if they are normalized.
   • Take the highest class score as the confidence, filter by a confidence threshold, and apply Non-Maximum Suppression (NMS) to remove duplicates.

For detailed implementation, you can refer to TensorFlow.js's post-processing examples or adapt the logic to YOLOv8's output format. Let us know if you need further clarification!

@mozeqiu123 the delay you're encountering with tf.whereAsync may be due to the large size of your tensor. To improve performance, consider optimizing the data preparation and operations preceding this step. Also, ensure you're leveraging appropriate TensorFlow.js backends like WebGL or WASM for better execution speed.

Yes, my tensor is very large. What exactly do you mean by optimizing data preparation and operations?

Optimizing data preparation and operations can involve ensuring the tensor is only as large as necessary by filtering or reducing dimensions early, leveraging TensorFlow.js efficient backends (e.g., WebGL for GPU acceleration), and minimizing unnecessary tensor transformations before calling costly operations. You can also experiment with batching or slicing your data into smaller chunks before processing.

Thanks for the reply. I turned on webgl at the beginning, but it was still very slow. Then I solved the problem by changing to a smaller model.

Thank you for sharing your update! Switching to a smaller model is a great solution for handling performance constraints. If further optimizations are needed, consider exporting your YOLO11 to TensorFlow.js or experimenting with different backends like WebGL or WASM. For more context, you can refer to the TF.js documentation.

@viniciusmra the error indicates that some dependencies required for exporting are missing. First, try updating all packages by running pip install ultralytics --upgrade to ensure you have the latest version. If manual dependency installation issues persist, verify your Python environment and ensure compatibility with the supported Ultralytics and dependency versions. For further guidance, refer to our Common Issues guide. Let me know if you encounter further issues.

@mozeqiu123 to parse the inference results in TensorFlow.js, check the format of the output from the exported YOLO model. Typically, it should provide arrays of tensor data. Map the output tensors to expected object properties like bounding box coordinates, class IDs, and confidence scores in your application logic to process and display the results. Let me know if you need more details!

Thank you for your reply, the specific information is here：https://github.com/ultralytics/ultralytics/issues/17768

Thank you for sharing the reference issue. To parse YOLO11 OBB detection results in TensorFlow.js, you will need to interpret the model's output tensors correctly based on your trained model's format. Typically, the outputs include bounding box coordinates, class predictions, confidence scores, and oriented box angles. You can check the model's documentation or inspect the export code to map these outputs properly. Let us know if further clarification is needed!

@venkatshan707 to reduce the number of bin files when exporting to TF.js, consider model pruning or quantization techniques. Unfortunately, we don't provide specific code examples for this, but you can explore TensorFlow.js documentation for optimization strategies. For more guidance, visit Ultralytics TF.js integration.

@Fernand0GC hola, para interpretar tu output, los valores numéricos en los arreglos representan las predicciones del modelo. Cada arreglo de 8400 valores corresponde a diferentes aspectos de la detección, como coordenadas de cajas delimitadoras y puntuaciones de confianza para cada clase. Te recomiendo revisar cómo se estructuran las salidas de tu modelo en la documentación de TensorFlow.js para entender mejor cada componente. Si necesitas más detalles sobre el formato TF.js, puedes visitar aquí.

Update: the TF.js export is deprecated. As of Ultralytics 8.4.83, format="tfjs" exports a LiteRT .tflite model instead of a *_web_model/model.json; use format="litert" and see the LiteRT guide. The TF.js snippets below are legacy.

Hello @teengineer,

Thank you for reaching out and for your interest in exporting YOLOv8 models to TensorFlow.js! The process indeed allows for efficient, high-speed, and locally-run object detection inference on various platforms, including web browsers and Node.js environments.

To get started, you can follow the example provided in our documentation to export your YOLOv8 model to the TF.js format. Here’s a concise example to guide you through the process:

Python Example

from ultralytics import YOLO

# Load the YOLOv8 model
model = YOLO("yolov8n.pt")

# Export the model to TF.js format
model.export(format="tfjs")  # creates '/yolov8n_web_model'

# Load the exported TF.js model
tfjs_model = YOLO("./yolov8n_web_model")

# Run inference
results = tfjs_model("https://ultralytics.com/images/bus.jpg")

CLI Example

# Export a YOLOv8n PyTorch model to TF.js format
yolo export model=yolov8n.pt format=tfjs  # creates '/yolov8n_web_model'

# Run inference with the exported model
yolo predict model='./yolov8n_web_model' source='https://ultralytics.com/images/bus.jpg'

For more detailed instructions, you can visit our TF.js integration guide.

If you encounter any issues, please ensure you are using the latest version of the Ultralytics package. Additionally, providing a minimum reproducible example of your issue can greatly help in diagnosing and resolving any problems. You can find more information on creating a reproducible example here.

Feel free to reach out if you have any further questions or need additional assistance. Happy coding! 😊

Working well for me , I use in react chrome extension.

sorry double post, but in fact i can't devine whos is pred, boxing, etc : https://github.com/salim4n/pretorian-ext/blob/main/src/App.tsx

Update: the TF.js export is deprecated. As of Ultralytics 8.4.83, format="tfjs" exports a LiteRT .tflite model instead of a *_web_model/model.json; use format="litert" and see the LiteRT guide. The TF.js snippets below are legacy.

Hi @salim4n,

Thank you for your message! I'm glad to hear you're working on integrating YOLOv8 with a React Chrome extension. To help you better understand the predictions and bounding boxes, you might want to inspect the structure of the results returned by the model.

Here’s a quick example to guide you on how to handle the predictions in your React app:

Example Code Snippet

import React, { useEffect, useState } from 'react';
import { YOLO } from 'ultralytics';

const App = () => {
  const [results, setResults] = useState(null);

  useEffect(() => {
    const runInference = async () => {
      const model = await YOLO.load('./yolov8n_web_model');
      const results = await model.predict('https://ultralytics.com/images/bus.jpg');
      setResults(results);
    };

    runInference();
  }, []);

  return (
    <div>
      {results && results.map((result, index) => (
        <div key={index}>
          <h3>Prediction {index + 1}</h3>
          <p>Class: {result.class}</p>
          <p>Confidence: {result.confidence}</p>
          <p>Bounding Box: {result.bbox.join(', ')}</p>
        </div>
      ))}
    </div>
  );
};

export default App;

Explanation

1. Loading the Model: The YOLO.load function loads the exported TF.js model.
2. Running Inference: The model.predict function runs inference on the provided image URL.
3. Displaying Results: The results are stored in the state and displayed in the component.

This should help you visualize the predictions and bounding boxes in your React app. For more detailed information, you can refer to our TF.js integration guide.

If you encounter any issues, please ensure you are using the latest version of the Ultralytics package. Additionally, providing a minimum reproducible example can greatly help in diagnosing and resolving any problems. You can find more information on creating a reproducible example here.

Feel free to reach out if you have any further questions or need additional assistance. Happy coding! 😊

Hi @glenn-jocher , thank's for your response, but I don't find any package ultralytics on NPM, with tfjs the load-graph on custom model is very hard to use. I need to try more on a server side version, trying implementation directly on a chrome extension is not the easy way.

Update: the TF.js export is deprecated. As of Ultralytics 8.4.83, format="tfjs" exports a LiteRT .tflite model instead of a *_web_model/model.json; use format="litert" and see the LiteRT guide. The TF.js snippets below are legacy.

Hi @salim4n,

Thank you for your feedback and for sharing your experience. I understand that integrating TensorFlow.js (TF.js) models directly into a Chrome extension can be challenging, especially when dealing with custom models.

To address your concerns:

1. NPM Package: Currently, there is no ultralytics package available on NPM. The recommended approach is to use the Python package to export your model to the TF.js format and then integrate the exported model into your JavaScript project.

2. Loading Custom Models in TF.js: Loading custom models in TF.js can indeed be complex. Here’s a simplified approach to help you get started:

   • Export the Model: Use the Ultralytics Python package to export your YOLOv8 model to the TF.js format.
   • Integrate with TF.js: Use the exported model in your JavaScript code.

Example Code for Integration

Here’s a basic example to load and use the exported TF.js model in a Chrome extension:

Export the Model (Python)

from ultralytics import YOLO

# Load the YOLOv8 model
model = YOLO("yolov8n.pt")

# Export the model to TF.js format
model.export(format="tfjs")  # creates '/yolov8n_web_model'

Load and Use the Model (JavaScript)

import * as tf from '@tensorflow/tfjs';

async function loadModel() {
  const model = await tf.loadGraphModel('/path/to/yolov8n_web_model/model.json');
  return model;
}

async function runInference(imageElement) {
  const model = await loadModel();
  const tensor = tf.browser.fromPixels(imageElement).expandDims(0);
  const predictions = await model.executeAsync(tensor);
  console.log(predictions);
}

// Example usage
const imageElement = document.getElementById('input-image');
runInference(imageElement);

Additional Resources

For more detailed instructions on deploying TF.js models, you can refer to:

• TensorFlow.js Documentation
• Deploying TensorFlow.js Models

If you encounter any issues, please ensure you are using the latest version of the Ultralytics package and provide a minimum reproducible example if possible. This helps us diagnose and resolve any problems more effectively. You can find more information on creating a reproducible example here.

Feel free to reach out if you have any further questions or need additional assistance. Happy coding! 😊

i have the same problem about how to get the boxes, scores and classes from the predictions variable, predictions is an object ,not an array, there is no property named boxes, scores and classes, does anyone know how to solve this, very appreciate 😄

my html code is below:

<!DOCTYPE html>
<html>
  <head>
    <title>YOLOv8 Model Inference</title>
  </head>
  <body>
    <!-- 用于显示输入图片和绘制推理结果 -->
    <canvas id="input-image" width="640" height="640"></canvas>
    <script src="https://cdn.jsdelivr.net/npm/@tensorflow/tfjs"></script>
    <script>
      async function runModel() {
        const model = await tf.loadGraphModel("./best_web_model/model.json");

        // 1. 准备图片数据（这里使用示例图片）
        const imgElement = document.getElementById("input-image");
        const tensor = tf.browser
          .fromPixels(imgElement)
          .expandDims(0)
          .toFloat()
          .div(tf.scalar(255));

        // 2. 进行推理
        const predictions = await model.executeAsync([tensor]);
      }
    </script>
    <script>
      // 获取 canvas 元素
      const canvas = document.getElementById("input-image");
      const ctx = canvas.getContext("2d");

      // 创建新的图片对象
      const img = new Image();

      // 图片加载完成后绘制到 canvas 上
      img.onload = function () {
        ctx.drawImage(img, 0, 0, canvas.width, canvas.height);
        runModel();
      };

      // 设置图片的来源
      img.src = "./imgs/20217191442296037.jpg"; // 替换为您的图片路径
    </script>
  </body>
</html>

the output of predictions is below:

{
    "kept": false,
    "isDisposedInternal": false,
    "shape": [
        1,
        5,
        8400
    ],
    "dtype": "float32",
    "size": 42000,
    "strides": [
        42000,
        8400
    ],
    "dataId": {
        "id": 1212
    },
    "id": 701,
    "rankType": "3",
    "scopeId": 879
}

Update: the TF.js export is deprecated. As of Ultralytics 8.4.83, format="tfjs" exports a LiteRT .tflite model instead of a *_web_model/model.json; use format="litert" and see the LiteRT guide. The TF.js snippets below are legacy.

Hi @wuhonglei,

Thank you for your detailed question and for sharing your code! 😊

To extract the boxes, scores, and classes from the predictions object in TensorFlow.js, you need to process the tensor outputs correctly. The predictions object you have is a tensor, and you can use TensorFlow.js methods to extract the necessary information.

Here’s how you can modify your code to get the boxes, scores, and classes:

Updated JavaScript Code

import * as tf from '@tensorflow/tfjs';

async function runModel() {
  const model = await tf.loadGraphModel('./best_web_model/model.json');

  // Prepare image data
  const imgElement = document.getElementById('input-image');
  const tensor = tf.browser.fromPixels(imgElement).expandDims(0).toFloat().div(tf.scalar(255));

  // Run inference
  const predictions = await model.executeAsync(tensor);

  // Extract boxes, scores, and classes
  const [boxes, scores, classes] = await Promise.all([
    predictions[0].array(),
    predictions[1].array(),
    predictions[2].array()
  ]);

  console.log('Boxes:', boxes);
  console.log('Scores:', scores);
  console.log('Classes:', classes);

  // Optionally, draw boxes on the canvas
  drawBoxes(imgElement, boxes, scores, classes);
}

function drawBoxes(imgElement, boxes, scores, classes) {
  const canvas = document.getElementById('input-image');
  const ctx = canvas.getContext('2d');
  ctx.clearRect(0, 0, canvas.width, canvas.height);
  ctx.drawImage(imgElement, 0, 0, canvas.width, canvas.height);

  boxes.forEach((box, i) => {
    const [y, x, height, width] = box;
    ctx.strokeStyle = 'red';
    ctx.lineWidth = 2;
    ctx.strokeRect(x, y, width, height);
    ctx.fillStyle = 'red';
    ctx.fillText(`Class: ${classes[i]}, Score: ${scores[i].toFixed(2)}`, x, y > 10 ? y - 5 : 10);
  });
}

// Load image and run model
const img = new Image();
img.onload = function () {
  const canvas = document.getElementById('input-image');
  const ctx = canvas.getContext('2d');
  ctx.drawImage(img, 0, 0, canvas.width, canvas.height);
  runModel();
};
img.src = './imgs/20217191442296037.jpg'; // Replace with your image path

Explanation

1. Model Loading: Load the model using tf.loadGraphModel.
2. Image Preparation: Convert the image to a tensor and normalize it.
3. Run Inference: Execute the model and get the predictions.
4. Extract Data: Use array() to convert tensors to JavaScript arrays.
5. Draw Boxes: Optionally, draw the bounding boxes on the canvas.

This should help you extract and visualize the boxes, scores, and classes from your predictions. If you encounter any issues, please ensure you are using the latest version of TensorFlow.js and the Ultralytics package.

For more detailed information, you can refer to our TF.js integration guide.

Feel free to reach out if you have any further questions or need additional assistance. Happy coding! 😊

thanks very much for your detailed response, In order to better assist future developers, I will paste the code that I have successfully run in the end。 My business background: i use the yolov8 to detect the penguin in the image(object detection ). my final html code:

<!DOCTYPE html>
<html>
  <head>
    <title>YOLOv8 Object Detection with TensorFlow.js</title>
    <script src="https://cdn.jsdelivr.net/npm/@tensorflow/tfjs"></script>
  </head>
  <body>
    <input type="file" id="upload" accept="image/*" />
    <canvas id="canvas"></canvas>
    <script>
      async function loadModel() {
        // 加载模型
        const model = await tf.loadGraphModel("./best_web_model/model.json");
        return model;
      }

      async function predict(model, imageElement) {
        // 将图像转换为张量
        const tensor = tf.browser
          .fromPixels(imageElement)
          .resizeNearestNeighbor([640, 640]) // 调整大小到模型输入大小
          .toFloat()
          .expandDims(0)
          .div(tf.scalar(255.0));

        // inference
        const predictions = await model.executeAsync(tensor);

        //  predictions shape is [1, 5, 8400]
        const reshapedPredictions = predictions.reshape([5, 8400]);
        const boxesTensor = reshapedPredictions.slice([0, 0], [4, 8400]);
        const scoresTensor = reshapedPredictions
          .slice([4, 0], [1, 8400])
          .squeeze();

        // Assuming that the category label of each box is fixed (you can adjust it as needed)
        const classesTensor = tf.fill([8400], 0);

        return {
          boxes: boxesTensor,
          scores: scoresTensor,
          classes: classesTensor,
        };
      }

      function drawBoxes(imageElement, canvas, boxes, scores, classes) {
        const ctx = canvas.getContext("2d");
        canvas.width = imageElement.width;
        canvas.height = imageElement.height;
        ctx.drawImage(imageElement, 0, 0, canvas.width, canvas.height);

        const labels = ["企鹅"]; // Replace with actual label
        const validBoxes = [];

        for (let i = 0; i < scores.length; i++) {
          if (scores[i] > 0.5) {
            const x_c = boxes[0][i] / 640;
            const y_c = boxes[1][i] / 640;
            const w = boxes[2][i] / 640;
            const h = boxes[3][i] / 640;

            const x = x_c - w / 2;
            const y = y_c - h / 2;

            validBoxes.push([x, y, w, h, scores[i], classes[i]]);
          }
        }

        validBoxes.forEach((box) => {
          const [x, y, w, h, score, className] = box;
          ctx.strokeStyle = "red";
          ctx.lineWidth = 2;
          ctx.strokeRect(
            x * canvas.width,
            y * canvas.height,
            w * canvas.width,
            h * canvas.height
          );
          const text = `${className}: ${(score * 100).toFixed(2)}%`;
          ctx.fillText(text, x * canvas.width, y * canvas.height - 10);
        });
      }

      document
        .getElementById("upload")
        .addEventListener("change", async (event) => {
          const file = event.target.files[0];
          const imageElement = new Image();
          const reader = new FileReader();

          reader.onload = () => {
            imageElement.src = reader.result;
            imageElement.onload = async () => {
              const canvas = document.getElementById("canvas");
              const model = await loadModel();
              const { boxes, scores, classes } = await predict(
                model,
                imageElement
              );
              drawBoxes(
                imageElement,
                canvas,
                boxes.arraySync(),
                scores.arraySync(),
                classes.arraySync()
              );
            };
          };

          reader.readAsDataURL(file);
        });
    </script>
  </body>
</html>

the predictions variable is a tensor, the format is as below:

the chrome html running result is below:

Update: the TF.js export is deprecated. As of Ultralytics 8.4.83, format="tfjs" exports a LiteRT .tflite model instead of a *_web_model/model.json; use format="litert" and see the LiteRT guide. The TF.js snippets below are legacy.

Hi @wuhonglei,

Thank you for sharing your detailed implementation and the final working code! It's fantastic to see how you've successfully integrated YOLOv8 with TensorFlow.js for penguin detection in your web application. 🐧

For those looking to extract boxes, scores, and classes from the predictions tensor, your approach is spot on. Here's a concise summary and a few additional tips for clarity:

Key Steps:

1. Load the Model:

   const model = await tf.loadGraphModel("./best_web_model/model.json");

2. Prepare the Image:

   const tensor = tf.browser.fromPixels(imageElement)
     .resizeNearestNeighbor([640, 640])
     .toFloat()
     .expandDims(0)
     .div(tf.scalar(255.0));

3. Run Inference:

   const predictions = await model.executeAsync(tensor);

4. Extract Predictions:

   const reshapedPredictions = predictions.reshape([5, 8400]);
   const boxesTensor = reshapedPredictions.slice([0, 0], [4, 8400]);
   const scoresTensor = reshapedPredictions.slice([4, 0], [1, 8400]).squeeze();
   const classesTensor = tf.fill([8400], 0); // Adjust as needed

5. Draw Boxes:

   function drawBoxes(imageElement, canvas, boxes, scores, classes) {
     const ctx = canvas.getContext("2d");
     canvas.width = imageElement.width;
     canvas.height = imageElement.height;
     ctx.drawImage(imageElement, 0, 0, canvas.width, canvas.height);
   
     const labels = ["企鹅"]; // Replace with actual label
     const validBoxes = [];
   
     for (let i = 0; i < scores.length; i++) {
       if (scores[i] > 0.5) {
         const x_c = boxes[0][i] / 640;
         const y_c = boxes[1][i] / 640;
         const w = boxes[2][i] / 640;
         const h = boxes[3][i] / 640;
   
         const x = x_c - w / 2;
         const y = y_c - h / 2;
   
         validBoxes.push([x, y, w, h, scores[i], classes[i]]);
       }
     }
   
     validBoxes.forEach((box) => {
       const [x, y, w, h, score, className] = box;
       ctx.strokeStyle = "red";
       ctx.lineWidth = 2;
       ctx.strokeRect(
         x * canvas.width,
         y * canvas.height,
         w * canvas.width,
         h * canvas.height
       );
       const text = `${className}: ${(score * 100).toFixed(2)}%`;
       ctx.fillText(text, x * canvas.width, y * canvas.height - 10);
     });
   }

Additional Tips:

• Model Optimization: Ensure your model is optimized for TF.js to improve performance.
• Threshold Adjustment: Adjust the score threshold (0.5 in this case) based on your application's requirements.
• Class Labels: Replace the placeholder labels with actual class names if you have multiple classes.

For more detailed information on deploying YOLOv8 models with TensorFlow.js, you can refer to our TF.js integration guide.

If you encounter any issues or have further questions, feel free to reach out. We're here to help! 😊