Teachable Machine Community Libraries

There are two ways to load a model depending on whether you are using remote URLs or local files.

Loading from URLs

Use tmPose.load() to load a model from a Teachable Machine checkpoint URL. The checkpoint URL should point to the directory containing model.json and metadata.json.

// Example: URL is the link provided by Teachable Machine export panel
const modelURL = 'https://teachablemachine.withgoogle.com/models/MODEL_ID/model.json';
const metadataURL = 'https://teachablemachine.withgoogle.com/models/MODEL_ID/metadata.json';
const model = await tmPose.load(modelURL, metadataURL);

Loading from local files

Use tmPose.loadFromFiles() to load model files directly from a user's local device (e.g., via a file picker). This requires three File objects.

// model, weights, and metadata must be File objects from an <input type='file'>
model = await tmPose.loadFromFiles(uploadModel.files[0], uploadWeights.files[0], uploadMetadata.files[0]);

You can use a Teachable Machine exported Keras model (.h5) and labels (labels.txt) in a Python environment by combining tensorflow/keras, opencv-python, and numpy.

Prerequisites

• TensorFlow/Keras: Required to load and run the .h5 model.
• OpenCV (opencv-python): Used for camera access and image processing.
• NumPy: Used for array manipulation and normalization.

Implementation Workflow

1. Load Assets: Use keras.models.load_model for the model and standard file I/O for the labels.txt file.
2. Capture Video: Initialize cv2.VideoCapture(0) to access the webcam.
3. Pre-process Image:
   • Resize the frame to (224, 224) using cv2.resize.
   • Convert the image to a NumPy array with dtype=np.float32.
   • Reshape the array to (1, 224, 224, 3) to match the model's expected input shape.
   • Normalize: Scale the pixel values using the formula (image / 127.5) - 1.
4. Inference: Call model.predict(image) to get confidence scores, then use np.argmax() to find the predicted class index.
5. Cleanup: Release the camera and close windows using camera.release() and cv2.destroyAllWindows().

from keras.models import load_model  # TensorFlow is required for Keras to work
import cv2  # Install opencv-python
import numpy as np

# Disable scientific notation for clarity
np.set_printoptions(suppress=True)

# Load the model
model = load_model("keras_Model.h5", compile=False)

# Load the labels
class_names = open("labels.txt", "r").readlines()

# CAMERA can be 0 or 1 based on default camera of your computer
camera = cv2.VideoCapture(0)

while True:
    # Grab the webcamera's image.
    ret, image = camera.read()

    # Resize the raw image into (224-height,224-width) pixels
    image = cv2.resize(image, (224, 224), interpolation=cv2.INTER_AREA)

    # Show the image in a window
    cv2.imshow("Webcam Image", image)

    # Make the image a numpy array and reshape it to the models input shape.
    image = np.asarray(image, dtype=np.float32).reshape(1, 224, 224, 3)

    # Normalize the image array
    image = (image / 127.5) - 1

    # Predicts the model
    prediction = model.predict(image)
    index = np.argmax(prediction)
    class_name = class_names[index]
    confidence_score = prediction[0][index]

    # Print prediction and confidence score
    print("Class:", class_name[2:], end="")
    print("Confidence Score:", str(np.round(confidence_score * 100))[:-2], "%")

    # Listen to the keyboard for presses.
    keyboard_input = cv2.waitKey(1)

    # 27 is the ASCII for the esc key on your keyboard.
    if keyboard_input == 27:
        break

camera.release()
cv2.destroyAllWindows()

To use a Teachable Machine image model in a Python environment, you can use keras.models.load_model to load the exported .h5 file and PIL (Pillow) for image preprocessing.

Preprocessing Requirements

1. Image Resizing: The image must be resized to at least 224x224 and center-cropped. Using ImageOps.fit with Image.Resampling.LANCZOS is recommended.
2. Normalization: Convert the image to a NumPy array and normalize the pixel values to a range of [-1, 1] using the formula: (image_array.astype(np.float32) / 127.5) - 1.
3. Data Shape: The model expects a 4D NumPy array with the shape (1, 224, 224, 3), where 1 represents the batch size (number of images).

Dependencies

• tensorflow (required for Keras)
• keras
• pillow (for image processing)
• numpy

from keras.models import load_model  # TensorFlow is required for Keras to work
from PIL import Image, ImageOps  # Install pillow instead of PIL
import numpy as np

# Disable scientific notation for clarity
np.set_printoptions(suppress=True)

# Load the model
model = load_model("keras_Model.h5", compile=False)

# Load the labels
class_names = open("labels.txt", "r").readlines()

# Create the array of the right shape to feed into the keras model
# The 'length' or number of images you can put into the array is
# determined by the first position in the shape tuple, in this case 1
data = np.ndarray(shape=(1, 224, 224, 3), dtype=np.float32)

# Replace this with the path to your image
image = Image.open("<IMAGE_PATH>").convert("RGB")

# resizing the image to be at least 224x224 and then cropping from the center
size = (224, 224)
image = ImageOps.fit(image, size, Image.Resampling.LANCZOS)

# turn the image into a numpy array
image_array = np.asarray(image)

# Normalize the image
normalized_image_array = (image_array.astype(np.float32) / 127.5) - 1

# Load the image into the array
data[0] = normalized_image_array

# Predicts the model
prediction = model.predict(data)
index = np.argmax(prediction)
class_name = class_names[index]
confidence_score = prediction[0][index]

# Print prediction and confidence score
print("Class:", class_name[2:], end="")
print("Confidence Score:", confidence_score)