LandingAI Python Library

The repository provides several example implementations categorized by type (Jupyter Notebooks for ease of use and Python applications for robust experiences):

Jupyter Notebooks

• Poker Card Suit Identification: Uses an object detection model from LandingLens to detect suits on playing cards via webcam.
• Door Monitoring for Home Automation: Uses an object detection model to detect if a door is open or closed using an RTSP camera.
• Satellite Images and Post-Processing: Uses a Visual Prompting model to identify objects in satellite images, including post-processing to calculate ground cover percentages.
• License Plate Detection and Recognition: Extracts frames from video files and uses object detection and OCR to identify and recognize license plates.

Python Applications

• Streaming Video: A continuous inference application running on images extracted from a streaming RTSP video camera feed.

Both the inspector and inference tools expect a model bundle organized in the following directory structure:

published_model_bundle/
├── model/
│   ├── before_train-saved_model.pth    # Pre-training PyTorch model
│   ├── qat-saved_model.pt              # QAT training TorchScript model
│   ├── qat_eval-saved_model.pt         # QAT evaluation TorchScript model
│   └── saved_model.tflite              # (Not supported)
├── model_meta/
│   ├── transforms.yaml                 # Image preprocessing (height/width)
│   └── train.yaml                      # Training config (score threshold)
├── dm.json                             # Defect map (class labels)
├── meta.json                           # Model metadata
└── original_dm.json                    # Original defect map

Important: The inference tool specifically requires .pt (TorchScript) files. The model_meta/ directory is critical for the inference tool to correctly preprocess images and filter results.

The landingai.predict.Predictor class is the primary abstraction for getting inference results from models trained in LandingLens. It abstracts away the complexities of server communication, error handling, and result parsing.

Key Mental Models:

• Computation Location: The actual model inference computation does not happen within the Python library; it occurs on the model server (either a LandingLens Cloud Deployment or your own server via LandingEdge).
• Deployment Support: The library currently supports Cloud Deployment. Edge Deployment support is planned for a future release.
• Rate Limiting: When using Cloud Deployment, there is a limit of 40 inferences per minute per endpoint. If you exceed this, the server returns a 429 Too Many Requests status code. By default, the Predictor.predict() method will automatically wait 60 seconds and retry if it encounters a 429 error.

from landingai.predict import Predictor

# Initialize the predictor with your endpoint and API key
predictor = Predictor(endpoint_id, api_key=api_key)

# Run inference
results = predictor.predict(img)

You can extract text from images using the landingai.predict.OcrPredictor class. This class provides pre-trained OCR models that work with various font types and handwriting.

Workflow

1. Initialize the Predictor: Create an OcrPredictor instance using your API key. You can optionally specify a language parameter:
   • ch: Supports Chinese and English characters (default).
   • en: Supports only English characters; may provide better accuracy if you know the image is exclusively English.
2. Prepare the Image: Create a Frame instance from an image source (e.g., a file path, webcam, or video).
3. Run Inference: Call frame.run_predict(predictor) to process the frame.
4. Access Results: Iterate through frame.predictions to access the extracted text and confidence scores.

from landingai.predict import OcrPredictor
from landingai.pipeline.image_source import Frame

# 1. Initialize predictor with API key and optional language
predictor = OcrPredictor(api_key="<insert your API key here>", language="en")

# 2. Create a Frame from an image
frame = Frame.from_image("/path/to/image.png")

# 3. Run inference
frame.run_predict(predictor)

# 4. Iterate over predictions
for prediction in frame.predictions:
    print(f"{prediction.text} (Confidence: {prediction.score})")