HOOPS AI SDK

https://docs.techsoft3d.com/hoops/ai/
Admin
HOOPS AI SDK is a Python framework designed to integrate Artificial Intelligence with 3D...
Tokens:468,166
Snippets:4,985
Trust Score:9.7
Update:4 months ago
Show doc for...
Tokens:
Raw
### Data Serving Example

Source: https://docs.techsoft3d.com/hoops/ai/_sources/tutorials/hoops_ai_tutorials/notebooks/4b_162k_dataserving.ipynb.txt

This snippet demonstrates a basic data serving setup. Ensure necessary libraries are installed.

```python
import os
import sys
import json
import time
import logging
import traceback
import pandas as pd
from flask import Flask, request, jsonify
from flask_cors import CORS
from datetime import datetime

# Set up logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')

# Initialize Flask app
app = Flask(__name__)
CORS(app)

# Load configuration
CONFIG_PATH = "config.json"

def load_config(path=CONFIG_PATH):
    try:
        with open(path, 'r') as f:
            config = json.load(f)
        logging.info(f"Loaded config from {path}")
        return config
    except FileNotFoundError:
        logging.error(f"Config file not found at {path}")
        return None
    except json.JSONDecodeError:
        logging.error(f"Error decoding JSON from {path}")
        return None

config = load_config()

# Load data
DATA_PATH = config.get("data_path", "data.csv")

def load_data(path=DATA_PATH):
    try:
        df = pd.read_csv(path)
        logging.info(f"Loaded data from {path} with {len(df)} rows")
        return df
    except FileNotFoundError:
        logging.error(f"Data file not found at {path}")
        return None
    except Exception as e:
        logging.error(f"Error loading data: {e}")
        return None

data = load_data()

# Define the root endpoint
@app.route('/')
def root():
    return "Hoops AI Data Serving API"

# Define the endpoint to get all data
@app.route('/data', methods=['GET'])
def get_data():
    if data is None:
        return jsonify({"error": "Data not loaded"}), 500
    try:
        # Convert DataFrame to JSON
        data_json = data.to_dict(orient='records')
        return jsonify(data_json)
    except Exception as e:
        logging.error(f"Error in /data endpoint: {e}")
        return jsonify({"error": "Internal server error"}), 500

# Define the endpoint to get data by ID
@app.route('/data/<int:id>', methods=['GET'])
def get_data_by_id(id):
    if data is None:
        return jsonify({"error": "Data not loaded"}), 500
    try:
        # Find the row with the specified ID (assuming 'id' is a column)
        row = data[data['id'] == id]
        if not row.empty:
            return jsonify(row.to_dict(orient='records')[0])
        else:
            return jsonify({"error": f"Record with id {id} not found"}), 404
    except KeyError:
        return jsonify({"error": "'id' column not found in data"}), 400
    except Exception as e:
        logging.error(f"Error in /data/<id> endpoint: {e}")
        return jsonify({"error": "Internal server error"}), 500

# Define the endpoint to add new data
@app.route('/data', methods=['POST'])
def add_data():
    if data is None:
        return jsonify({"error": "Data not loaded"}), 500
    try:
        new_record = request.get_json()
        if not new_record:
            return jsonify({"error": "Invalid JSON payload"}), 400

        # Add new record to the DataFrame (this is in-memory and will be lost on restart)
        # For persistent storage, you would save to a database or file here
        global data
        new_df = pd.DataFrame([new_record])
        data = pd.concat([data, new_df], ignore_index=True)

        logging.info(f"Added new record: {new_record}")
        return jsonify({"message": "Record added successfully"}), 201
    except Exception as e:
        logging.error(f"Error in POST /data endpoint: {e}")
        return jsonify({"error": "Internal server error"}), 500

# Define the endpoint to update data by ID
@app.route('/data/<int:id>', methods=['PUT'])
def update_data(id):
    if data is None:
        return jsonify({"error": "Data not loaded"}), 500
    try:
        update_payload = request.get_json()
        if not update_payload:
            return jsonify({"error": "Invalid JSON payload"}), 400

        # Find the index of the row with the specified ID
        index = data[data['id'] == id].index

        if not index.empty:
            # Update the record (in-memory)
            global data
            data.loc[index, update_payload.keys()] = update_payload.values()
            logging.info(f"Updated record with id {id}: {update_payload}")
            return jsonify({"message": f"Record with id {id} updated successfully"})
        else:
            return jsonify({"error": f"Record with id {id} not found"}), 404
    except KeyError as e:
        return jsonify({"error": f"Column not found: {e}"}), 400
    except Exception as e:
        logging.error(f"Error in PUT /data/<id> endpoint: {e}")
        return jsonify({"error": "Internal server error"}), 500

# Define the endpoint to delete data by ID
@app.route('/data/<int:id>', methods=['DELETE'])
def delete_data(id):
    if data is None:
        return jsonify({"error": "Data not loaded"}), 500
    try:
        # Find the index of the row with the specified ID
        index = data[data['id'] == id].index

        if not index.empty:
            # Delete the record (in-memory)
            global data
            data = data.drop(index)
            logging.info(f"Deleted record with id {id}")
            return jsonify({"message": f"Record with id {id} deleted successfully"})
        else:
            return jsonify({"error": f"Record with id {id} not found"}), 404
    except Exception as e:
        logging.error(f"Error in DELETE /data/<id> endpoint: {e}")
        return jsonify({"error": "Internal server error"}), 500

# Main execution block
if __name__ == '__main__':
    # Get port from config or use default
    port = config.get("port", 5000) if config else 5000
    app.run(host='0.0.0.0', port=port, debug=True)

```

--------------------------------

### Data Serving Example

Source: https://docs.techsoft3d.com/hoops/ai/_sources/tutorials/hoops_ai_tutorials/notebooks/4b_162k_dataserving.ipynb.txt

This snippet demonstrates a basic data serving setup. Ensure necessary libraries are installed and data paths are correctly configured.

```python
import os
import sys

import numpy as np
import pandas as pd

from hoops.ai.data import HoopsDataset
from hoops.ai.data.serving import HoopsDataServer

# Define the path to your dataset
dataset_path = "/mnt/data/hoops_ai_datasets/162k_dataset"

# Initialize the HoopsDataset
dataset = HoopsDataset(dataset_path)

# Initialize the HoopsDataServer
data_server = HoopsDataServer(dataset)

# Start the data server
data_server.start()

# You can now access data through the server, for example:
# data = data_server.get_data(sample_ids=["id_0001", "id_0002"])

# To stop the server when done:
# data_server.stop()
```

--------------------------------

### Data Serving Example

Source: https://docs.techsoft3d.com/hoops/ai/_sources/tutorials/hoops_ai_tutorials/notebooks/4b_162k_dataserving.ipynb.txt

This snippet illustrates a basic data serving setup. Ensure necessary libraries are imported.

```python
import numpy as np
import pandas as pd
from typing import List, Dict, Any

from hoops_ai.data_serving.data_serving import DataServing
from hoops_ai.data_serving.data_serving_utils import DataServingUtils

# Example data
data = {
    "col1": np.random.rand(100),
    "col2": np.random.randint(0, 100, 100),
    "col3": np.random.choice(["A", "B", "C"], 100),
}
df = pd.DataFrame(data)

# Initialize DataServing
dataserving = DataServing(df)

# Get data
print(dataserving.get_data())

# Get data with filters
print(dataserving.get_data(filters={"col2": {"$lt": 50}}))

# Get data with sorting
print(dataserving.get_data(sort={"col1": "desc"}))

# Get data with pagination
print(dataserving.get_data(page=1, page_size=10))

# Get data with aggregation
print(dataserving.get_data(aggregation={"col": "col3", "agg": "count"}))

# Get data with multiple filters, sorting, and pagination
print(dataserving.get_data(
    filters={"col2": {"$lt": 50}},
    sort={"col1": "desc"},
    page=1,
    page_size=10,
))

# Get data with multiple aggregations
print(dataserving.get_data(
    aggregation=[
        {"col": "col3", "agg": "count"},
        {"col": "col2", "agg": "mean"},
    ]
))

# Get data with complex filters
print(dataserving.get_data(
    filters={"col2": {"$lt": 50, "$gt": 20}, "col3": {"$in": ["A", "B"]}},
    sort={"col1": "desc"},
    page=1,
    page_size=10,
))

```

--------------------------------

### Data Serving Example

Source: https://docs.techsoft3d.com/hoops/ai/_sources/tutorials/hoops_ai_tutorials/notebooks/4b_162k_dataserving.ipynb.txt

Demonstrates a basic data serving setup. This example assumes a pre-trained model and a defined API endpoint.

```python
from flask import Flask, request, jsonify
import joblib

app = Flask(__name__)

# Load the pre-trained model
model = joblib.load('model.pkl')

@app.route('/predict', methods=['POST'])
def predict():
    data = request.get_json(force=True)
    prediction = model.predict([list(data.values())])
    
    output = {
        'prediction': prediction[0]
    }
    return jsonify(output)

if __name__ == '__main__':
    app.run(port=5000, debug=True)
```

--------------------------------

### Quick Setup with Templates

Source: https://docs.techsoft3d.com/hoops/ai/programming_guide/datasets.html

Import necessary functions for creating CAD schemas and initializing storage for a quick setup.

```python
from hoops_ai.storage.datasetstorage import create_cad_schema
from hoops_ai.storage import OptStorage
```

--------------------------------

### Real-time Data Serving Example

Source: https://docs.techsoft3d.com/hoops/ai/_sources/tutorials/hoops_ai_tutorials/notebooks/4b_162k_dataserving.ipynb.txt

This snippet illustrates a basic setup for real-time data serving, likely using a web framework. It shows how to receive data, preprocess it, and return a prediction.

```python
from flask import Flask, request, jsonify
import joblib
import pandas as pd
import numpy as np

app = Flask(__name__)

# Load the trained model and preprocessor
# Ensure these paths are correct for your deployment environment
model = joblib.load('hoops_ai_model.pkl')
preprocessor = joblib.load('hoops_ai_preprocessor.pkl')

@app.route('/predict', methods=['POST'])
def predict():
    try:
        data = request.get_json(force=True)
        
        # Convert JSON data to DataFrame
        # Assuming the input JSON has keys matching the original feature names
        df_input = pd.DataFrame([data])
        
        # Preprocess the input data using the loaded preprocessor
        # The preprocessor expects a DataFrame with original column names
        processed_data = preprocessor.transform(df_input)
        
        # Make prediction
        prediction = model.predict(processed_data)
        
        # Return prediction
        return jsonify({'prediction': prediction.tolist()})

    except Exception as e:
        return jsonify({'error': str(e)}), 400

if __name__ == '__main__':
    # Run the Flask app
    # In production, use a production-ready WSGI server like Gunicorn
    app.run(host='0.0.0.0', port=5000, debug=True)
```

--------------------------------

### Basic Data Serving Setup

Source: https://docs.techsoft3d.com/hoops/ai/_sources/tutorials/hoops_ai_tutorials/notebooks/4a_5k_dataserving.ipynb.txt

Illustrates a minimal setup for serving data. This is useful for quick testing or simple deployments.

```python
from hoops.data import Dataset
from hoops.serving import DataServer

data_server = DataServer(dataset)
data_server.start()
```

--------------------------------

### Complete Dataset Exploration and ML Preparation Workflow

Source: https://docs.techsoft3d.com/hoops/ai/_sources/programming_guide/explore-dataset.rst.txt

This example demonstrates a typical end-to-end workflow, starting with dataset exploration using DatasetExplorer and progressing to ML dataset preparation with DatasetLoader. It covers printing dataset contents, creating distributions, filtering files, performing stratified splits, and converting data for PyTorch.

```python
import hoops_ai
from hoops_ai.flowmanager import flowtask
from hoops_ai.dataset import DatasetExplorer, DatasetLoader
import pathlib

# Assume flow already executed and created:
# - cad_pipeline.dataset
# - cad_pipeline.infoset
# - cad_pipeline.attribset
# - cad_pipeline.flow

flow_file = pathlib.Path("flow_output/flows/cad_pipeline/cad_pipeline.flow")

# ===== STEP 1: Explore Dataset =====
print("="*70)
print("STEP 1: DATASET EXPLORATION")
print("="*70)

explorer = DatasetExplorer(flow_output_file=str(flow_file))

# Print overview
explorer.print_table_of_contents()

# Analyze face area distribution
face_dist = explorer.create_distribution(key="face_areas", group="faces", bins=20)
print(f"\nFace area distribution:")
print(f"  Range: [{face_dist['bin_edges'][0]:.2f}, {face_dist['bin_edges'][-1]:.2f}]")
print(f"  Total faces: {face_dist['hist'].sum()}")
print(f"  Mean bin count: {face_dist['hist'].mean():.1f}")

# Filter files by complexity
high_complexity_filter = lambda ds: ds['complexity_level'] >= 4
complex_files = explorer.get_file_list(group="faces", where=high_complexity_filter)
print(f"\nHigh complexity files: {len(complex_files)}")

# Close explorer
explorer.close()

# ===== STEP 2: Prepare ML Dataset =====
print("\n" + "="*70)
print("STEP 2: ML DATASET PREPARATION")
print("="*70)

# Initialize loader
flow_path = pathlib.Path(flow_file)
loader = DatasetLoader(
    merged_store_path=str(flow_path.parent / f"{flow_path.stem}.dataset"),
    parquet_file_path=str(flow_path.parent / f"{flow_path.stem}.infoset")
)

# Stratified split
train_size, val_size, test_size = loader.split(
    key="complexity_level",
    group="faces",
    train=0.7,
    validation=0.15,
    test=0.15,
    random_state=42
)

print(f"\nDataset split:")
print(f"  Train: {train_size} files")
print(f"  Validation: {val_size} files")
print(f"  Test: {test_size} files")

# Get datasets
train_dataset = loader.get_dataset("train")
val_dataset = loader.get_dataset("validation")
test_dataset = loader.get_dataset("test")

# ===== STEP 3: Prepare for Training =====
print("\n" + "="*70)
print("STEP 3: PYTORCH INTEGRATION")
print("="*70)

from torch.utils.data import DataLoader

# Convert to PyTorch
train_torch = train_dataset.to_torch()
val_torch = val_dataset.to_torch()

# Create data loaders
train_loader = DataLoader(train_torch, batch_size=32, shuffle=True, num_workers=4)
val_loader = DataLoader(val_torch, batch_size=32, shuffle=False, num_workers=4)

print(f"\nDataLoaders created:")
print(f"  Train batches: {len(train_loader)}")
print(f"  Val batches: {len(val_loader)}")

# Test iteration
batch = next(iter(train_loader))
print(f"\nSample batch keys: {list(batch.keys())}")

# ===== STEP 4: Training Loop (Skeleton) =====
print("\n" + "="*70)
print("STEP 4: TRAINING (SKELETON)")
print("="*70)

num_epochs = 10
for epoch in range(num_epochs):
    print(f"\nEpoch {epoch+1}/{num_epochs}")
    
    # Training phase
    for batch_idx, batch in enumerate(train_loader):
        # Your training code here
        pass
    
    # Validation phase
    for batch in val_loader:
        # Your validation code here
        pass

print("\nWorkflow complete!")
loader.close_resources()
```

--------------------------------

### Basic Data Serving Setup

Source: https://docs.techsoft3d.com/hoops/ai/_sources/tutorials/hoops_ai_tutorials/notebooks/4a_5k_dataserving.ipynb.txt

This snippet demonstrates the fundamental setup for serving data. It initializes the necessary components and prepares the environment for data operations.

```python
from hoops_ai.data import DataServer

data_server = DataServer()
data_server.start()
```

--------------------------------

### Quick Start with DatasetExplorer and DatasetLoader

Source: https://docs.techsoft3d.com/hoops/ai/_sources/programming_guide/dataset-merger.rst.txt

Demonstrates basic usage of DatasetExplorer and DatasetLoader with merged datasets. This example requires the DatasetExplorer and DatasetLoader classes to be available.

```python
# Example usage of DatasetExplorer and DatasetLoader
# from dataset_explorer import DatasetExplorer
# from dataset_loader import DatasetLoader

# explorer = DatasetExplorer("path/to/merged/dataset")
# loader = DatasetLoader("path/to/merged/dataset")

# print(explorer.get_summary())
# X_train, y_train = loader.get_train_data()

```

--------------------------------

### Data Loading and Transformation Example

Source: https://docs.techsoft3d.com/hoops/ai/_sources/tutorials/hoops_ai_tutorials/notebooks/3a_ETL_pipeline_using_flow.ipynb.txt

This snippet demonstrates loading data and performing transformations. It assumes necessary imports and setup are already completed.

```python
import pandas as pd
import numpy as np

# Load data from a CSV file
df = pd.read_csv("data.csv")

# Example transformation: Fill missing values with the mean
df.fillna(df.mean(), inplace=True)

# Example transformation: Add a new column based on existing ones
df['new_column'] = df['column1'] * df['column2']

# Display the first 5 rows of the transformed DataFrame
print(df.head())

```

--------------------------------

### Basic Data Serving Setup

Source: https://docs.techsoft3d.com/hoops/ai/_sources/tutorials/hoops_ai_tutorials/notebooks/4a_5k_dataserving.ipynb.txt

This snippet demonstrates a fundamental setup for serving data. It's useful for initializing data serving processes and ensuring basic connectivity.

```python
from typing import List

import numpy as np

from hoops_ai.data_serving.data_server import DataServer
from hoops_ai.data_serving.data_source import DataSource


def main():
    # Define data sources
    data_sources: List[DataSource] = [
        DataSource(name="source1", path="/path/to/source1", type="type1"),
        DataSource(name="source2", path="/path/to/source2", type="type2"),
    ]

    # Initialize DataServer
    server = DataServer(data_sources=data_sources)

    # Start the server
    server.start()

    # Example: Get data from a source
    data = server.get_data(source_name="source1")
    print(f"Data from source1: {data}")

    # Example: Simulate data processing
    processed_data = np.array(data) * 2
    print(f"Processed data: {processed_data}")

    # Stop the server when done
    server.stop()

if __name__ == "__main__":
    main()

```

--------------------------------

### Basic Data Serving Setup

Source: https://docs.techsoft3d.com/hoops/ai/_sources/tutorials/hoops_ai_tutorials/notebooks/4a_5k_dataserving.ipynb.txt

This snippet shows the fundamental setup for serving data. It initializes the Hoops AI environment and prepares for data operations.

```python
import hoops_ai

# Initialize Hoops AI
hoops_ai.init()

# Placeholder for data serving logic
print("Hoops AI initialized for data serving.")
```

--------------------------------

### Basic Data Serving Setup

Source: https://docs.techsoft3d.com/hoops/ai/_sources/tutorials/hoops_ai_tutorials/notebooks/4a_5k_dataserving.ipynb.txt

This snippet demonstrates a basic setup for serving data, likely for AI model training or inference. It initializes necessary components and prepares for data requests.

```python
import os
import sys

from flask import Flask, request, jsonify

# Add the project root to the Python path
project_root = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..'))
sys.path.insert(0, project_root)

from hoops_ai.serving.data_serving import DataServer

app = Flask(__name__)

# Initialize the DataServer
data_server = DataServer()

@app.route('/data', methods=['POST'])
def get_data():
    """Endpoint to serve data based on POST request parameters."""
    try:
        data = request.get_json()
        if not data:
            return jsonify({'error': 'Invalid JSON payload'}), 400

        response = data_server.get_data(data)
        return jsonify(response)
    except Exception as e:
        return jsonify({'error': str(e)}), 500

if __name__ == '__main__':
    # Run the Flask app
    # Use host='0.0.0.0' to make it accessible externally
    app.run(host='0.0.0.0', port=5000, debug=True)
```

--------------------------------

### Start Training and Get Best Checkpoint

Source: https://docs.techsoft3d.com/hoops/ai/_sources/programming_guide/part-class.rst.txt

Initiates the training process and returns the path to the best performing model checkpoint.

```python
# Train and get best checkpoint
best_checkpoint = trainer.train()
print(f"Training complete! Best model: {best_checkpoint}")
```

--------------------------------

### Load and Run Inference Example

Source: https://docs.techsoft3d.com/hoops/ai/programming_guide/train.html

An example demonstrating loading a model checkpoint and then performing preprocessing and prediction on a new CAD file.

```python
inference = FlowInference(
    cad_loader=HOOPSLoader(),
    flowmodel=GraphClassification(num_classes=26)
)

# Load the trained model
inference.load_from_checkpoint("results/ml_output/exp/0128/143052/best.ckpt")

# Now ready for inference
batch = inference.preprocess("new_part.step")
prediction = inference.predict_and_postprocess(batch)

```

--------------------------------

### HOOPS AI Data Serving Start

Source: https://docs.techsoft3d.com/hoops/ai/_sources/tutorials/hoops_ai_tutorials/notebooks/4b_162k_dataserving.ipynb.txt

Starts the data serving process. This command should be run after configuration is verified.

```python
dataserving.start()
```

--------------------------------

### Data Serving Example

Source: https://docs.techsoft3d.com/hoops/ai/_sources/tutorials/hoops_ai_tutorials/notebooks/4a_5k_dataserving.ipynb.txt

This snippet shows a basic example of data serving, likely for AI model training or inference. It involves data preparation and serving logic.

```python
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
```

--------------------------------

### Accessing CAD File Data

Source: https://docs.techsoft3d.com/hoops/ai/_sources/tutorials/hoops_ai_tutorials/notebooks/1_access_a_cad_file.ipynb.txt

After loading a file, you can access its data. This example shows how to get the file path.

```python
from hoops_ai.api import HoopsAI

api = HoopsAI()
api.load_cad_file('path/to/your/cadfile.ext')

# Get the loaded file path
loaded_file_path = api.get_loaded_file_path()
print(f"Loaded file: {loaded_file_path}")
```

--------------------------------

### Visualize Data with Matplotlib

Source: https://docs.techsoft3d.com/hoops/ai/_sources/tutorials/hoops_ai_tutorials/notebooks/4b_162k_dataserving.ipynb.txt

This example shows how to visualize bounding box data using Matplotlib. It requires Matplotlib and Pillow to be installed.

```python
import matplotlib.pyplot as plt
import matplotlib.patches as patches
from PIL import Image
import os

def plot_image_with_boxes(image_path, boxes):
    """Plots an image with bounding boxes."""
    img = Image.open(image_path).convert("RGB")
    fig, ax = plt.subplots(1)
    ax.imshow(img)

    for box in boxes:
        rect = patches.Rectangle(
            (box["x_min"], box["y_min"]),
            box["x_max"] - box["x_min"],
            box["y_max"] - box["y_min"],
            linewidth=1,
            edgecolor="r",
            facecolor="none",
        )
        ax.add_patch(rect)

    plt.show()

# Example usage:
image_dir = "../data/images/"
image_id = data[0]["image_id"]
image_path = os.path.join(image_dir, image_id + ".jpg")

# Filter boxes for the specific image
boxes_for_image = [d for d in data if d["image_id"] == image_id]

plot_image_with_boxes(image_path, boxes_for_image)
```

--------------------------------

### Initialize and Apply Schema to Storage

Source: https://docs.techsoft3d.com/hoops/ai/programming_guide/datasets.html

Set up OptStorage with a specified path and apply the previously built schema.

```python
from hoops_ai.storage import OptStorage

storage = OptStorage(store_path="./encoded/part_001.zarr")
storage.set_schema(schema)
```

--------------------------------

### Accessing HOOPS AI Path

Source: https://docs.techsoft3d.com/hoops/ai/_sources/tutorials/hoops_ai_tutorials/notebooks/1_access_a_cad_file.ipynb.txt

This example demonstrates how to retrieve the path to the HOOPS AI installation directory. This is useful for locating configuration files or other resources.

```python
from hoops_ai.utils import get_hoops_ai_path

# Get the HOOPS AI path
hp_ai_path = get_hoops_ai_path()

print(f"HOOPS AI path: {hp_ai_path}")
```

--------------------------------

### Data Serving Setup

Source: https://docs.techsoft3d.com/hoops/ai/_sources/tutorials/hoops_ai_tutorials/notebooks/4a_5k_dataserving.ipynb.txt

Initializes the data serving environment and loads necessary configurations. This is a prerequisite for most data serving operations.

```python
import os
import sys

from hoops_ai.core.config import Config
from hoops_ai.core.data_serving import DataServing

# Set up project path
project_path = "/websites/techsoft3d_hoops_ai"
sys.path.append(project_path)

# Load configuration
config = Config(project_path=project_path)

# Initialize DataServing
dataserving = DataServing(config=config)
```

--------------------------------

### Initialize GraphClassification with Basic Parameters

Source: https://docs.techsoft3d.com/hoops/ai/programming_guide/part-class.html

Create a GraphClassification instance for a 10-class classification task, saving results to a specified directory. This is the simplest way to get started.

```python
from hoops_ai.ml.EXPERIMENTAL import GraphClassification

# Create model with default parameters
flow_model = GraphClassification(
    num_classes=10,
    result_dir="./results"
)

```

--------------------------------

### Example Flow Log Output

Source: https://docs.techsoft3d.com/hoops/ai/_sources/programming_guide/flow.rst.txt

Shows a sample log output detailing the start and end of a manufacturing pipeline flow, including task summaries and execution times.

```text
2025-01-15 14:30:00 - INFO - ######### Flow 'manufacturing_pipeline' start #######
2025-01-15 14:30:00 - INFO - Flow Execution Summary
2025-01-15 14:30:00 - INFO - Task 1: gather_cad_files
2025-01-15 14:30:00 - INFO -     Inputs : cad_datasources
2025-01-15 14:30:00 - INFO -     Outputs: cad_dataset
2025-01-15 14:30:05 - INFO - Executing ParallelTask 'gather_cad_files' with 100 items.
2025-01-15 14:30:10 - INFO - Task 2: encode_manufacturing_data
2025-01-15 14:30:10 - INFO - Using ProcessPoolExecutor with 8 worker processes
2025-01-15 14:32:25 - INFO - Time taken: 145.32 seconds
2025-01-15 14:32:25 - INFO - ######### Flow 'manufacturing_pipeline' end ######
```

--------------------------------

### Instantiate ContextPredictor with NearestNeighborRule

Source: https://docs.techsoft3d.com/hoops/ai/api_ref/hoops_ai.ml.context_layer.html

Example of initializing a ContextPredictor with a specific per-key rule, such as NearestNeighborRule for 'InternalFeatures'. This setup allows the predictor to use the value of the most similar shape when similarity is high.

```python
from hoops_ai.ml.context_layer import (
    ContextPredictor, NearestNeighborRule,
)

predictor = ContextPredictor(
    provider, per_key_rules={
        "InternalFeatures": NearestNeighborRule(threshold=0.95),
    },
)
```

--------------------------------

### Initialize and Use DatasetViewer

Source: https://docs.techsoft3d.com/hoops/ai/_sources/programming_guide/dataset_viewer_search_results.rst.txt

Demonstrates how to initialize the DatasetViewer and use the show_search_results method. It also shows how to properly close the viewer to release resources.

```python
viewer = DatasetViewer(file_ids=[], png_paths=[], scs_paths=[])
viewer.show_search_results(hits)
viewer.close()
```

--------------------------------

### CAD Task Definition File Example

Source: https://docs.techsoft3d.com/hoops/ai/_sources/programming_guide/flow.rst.txt

A Python file defining tasks for CAD processing, including license setup, schema definition, and a task to gather CAD files. This demonstrates module-level definitions required for worker processes.

```python
"""Complete example of CAD processing tasks for part classification"""

import os
import glob
import random
import numpy as np
import hoops_ai
from hoops_ai.flowmanager import flowtask
from hoops_ai.cadaccess import HOOPSLoader, HOOPSTools
from hoops_ai.cadencoder import BrepEncoder
from hoops_ai.storage import DataStorage
from hoops_ai.storage.datasetstorage.schema_builder import SchemaBuilder

# License setup (module level)
license_key = os.getenv("HOOPS_AI_LICENSE")
if license_key:
    hoops_ai.set_license(license_key, validate=False)

# Schema definition (module level)
builder = SchemaBuilder(domain="Part_Classification", version="1.0")

# Faces group
faces_group = builder.create_group("faces", "face", "Face-level geometric data")
faces_group.create_array("face_areas", ["face"], "float32", "Face surface areas")
faces_group.create_array("face_types", ["face"], "int32", "Face type codes")

# Labels group
labels_group = builder.create_group("labels", "part", "Part classification labels")
labels_group.create_array("part_category", ["part"], "int32", "Part category (0-9)")
labels_group.create_array("complexity_score", ["part"], "float32", "Complexity rating")

# Metadata routing
builder.define_file_metadata('processing_time', 'float32', 'Encoding duration in seconds')
builder.define_categorical_metadata('category_name', 'str', 'Human-readable category')

cad_schema = builder.build()

@flowtask.extract(
    name="gather_part_files",
    inputs=["cad_datasources"],
    outputs=["cad_dataset"]
)
def gather_parts(source: str):
    """Gather STEP files from source directory"""
    patterns = ["*.step", "*.stp"]
    files = []
    for pattern in patterns:
        files.extend(glob.glob(f"{source}/**/{pattern}", recursive=True))
    print(f"Found {len(files)} CAD files")
    return files
```

--------------------------------

### Data Serving Configuration Example

Source: https://docs.techsoft3d.com/hoops/ai/_sources/tutorials/hoops_ai_tutorials/notebooks/4a_5k_dataserving.ipynb.txt

This snippet demonstrates a basic configuration for data serving, likely for setting up data pipelines or model training environments. Ensure correct paths and parameters are used.

```python
import os
import sys

# Add project root to sys.path
project_root = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..'))
sys.path.insert(0, project_root)

from hoops_ai.data_serving.data_serving import DataServing

# Example usage
serving = DataServing()
serving.load_data_config("config/data_serving_config.yaml")
serving.prepare_data()
serving.serve_data()
```

--------------------------------

### Data Serving with Custom Configuration

Source: https://docs.techsoft3d.com/hoops/ai/_sources/tutorials/hoops_ai_tutorials/notebooks/4a_5k_dataserving.ipynb.txt

This example shows how to configure the DataServer with custom parameters. Use this when specific settings are required for your data serving environment.

```python
from typing import List

from hoops_ai.data_serving.data_server import DataServer
from hoops_ai.data_serving.data_source import DataSource


def main():
    # Define data sources with specific configurations
    data_sources: List[DataSource] = [
        DataSource(name="source_A", path="/data/A", type="csv", config={"delimiter": ","}),
        DataSource(name="source_B", path="/data/B", type="json", config={"encoding": "utf-8"}),
    ]

    # Initialize DataServer with custom port and buffer size
    server = DataServer(data_sources=data_sources, port=8080, buffer_size=1024)

    # Start the server
    server.start()

    print("Data server started on port 8080 with custom configuration.")

    # Keep the server running (e.g., in a real application, this might be a loop or a service)
    try:
        while True:
            pass
    except KeyboardInterrupt:
        print("Stopping server...")
        server.stop()
        print("Server stopped.")

if __name__ == "__main__":
    main()

```
Tokens:
Raw