getML

https://getml.com/latest/
Admin
getML is a high-performance machine learning software suite for predictive analytics on relational...
Tokens:490,646
Snippets:2,386
Trust Score:5.6
Update:1 year ago
Show doc for...
Tokens:
Raw
### Launch getML Engine

Source: https://getml.com/latest/user_guide/quick_start

Initializes the getML engine and sets the project name. This is the first step in any getML workflow.

```Python
import getml

getml.engine.launch()
getml.engine.set_project('one_minute_to_getml')
```

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

### Install GetML and Dependencies

Source: https://getml.com/latest/examples/enterprise-notebooks/kaggle_notebooks/epilepsy_recognition

Installs the getML library along with numpy, matplotlib, and seaborn with specified version constraints. This command ensures all necessary tools are available for the project.

```Python
%pip install -q "getml==1.5.0" "numpy<2.0.0" "matplotlib~=3.9" "seaborn~=0.13"
```

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

### Install and Launch getML Engine

Source: https://getml.com/latest/examples/community-notebooks/seznam

Installs the getML library and launches the getML engine. It also sets the project to 'seznam'. This is the initial setup for using getML for predictive modeling.

```Python
%pip install -q "getml==1.5.0"

import getml

getml.engine.launch()
getml.set_project('seznam')

```

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

### Deploy Pipeline

Source: https://getml.com/latest/user_guide/quick_start

Deploys the trained getML pipeline, allowing it to respond to HTTP requests. This makes the model accessible for real-time predictions.

```Python
# Allow the pipeline to respond to HTTP requests
pipe.deploy(True)
```

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

### Install getML and Matplotlib, Launch getML Engine

Source: https://getml.com/latest/examples/community-notebooks/loans

Installs the getML library and Matplotlib, then launches the getML engine and sets the project to 'loans'. This is the initial setup for running the predictive modeling notebook.

```Python
%pip install -q "getml==1.5.0" "matplotlib~=3.9"

import matplotlib.pyplot as plt
%matplotlib inline

import getml

getml.engine.launch()
getml.engine.set_project("loans")

```

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

### Install getML Python API on macOS, Windows, and Linux via Docker

Source: https://getml.com/latest/install

Installs the getML Python API using pip and sets up the Engine within a Docker container. This approach is recommended for macOS, Windows, and Linux users who prefer a containerized environment.

```Bash
pip install getml
```

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

### Load Data into Engine

Source: https://getml.com/latest/user_guide/quick_start

Loads data from CSV files into getML DataFrames, assigning names for later reference. Supports loading multiple data sources.

```Python
df_population = getml.data.DataFrame.from_csv('data_population.csv',
            name='population_table')
df_peripheral = getml.data.DataFrame.from_csv('data_peripheral.csv',
            name='peripheral_table')
```

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

### Clone getML Demo and Run Docker Compose

Source: https://getml.com/latest/blog/getml-1-5-release

This snippet demonstrates how to clone the getML demo repository and start the notebooks environment using Docker Compose. It's designed for quick setup and experimentation with getML.

```Shell
git clone https://github.com/getml/getml-demo.git
docker compose up notebooks
```

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

### Train Feature Learning and Predictor

Source: https://getml.com/latest/user_guide/quick_start

Configures and trains a getML Pipeline, specifying feature learners and predictors. The `fit` method trains the model using the provided data.

```Python
pipe = getml.pipeline.Pipeline(
    data_model=dm,
    feature_learners=getml.feature_learning.FastProp(),
    predictors=getml.predictors.LinearRegression()
)
pipe.fit(
    population=df_population,
    peripheral=[df_peripheral]
)
```

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

### Install getML and Dependencies

Source: https://getml.com/latest/examples/enterprise-notebooks/kaggle_notebooks/getml-and-gnns-a-natural-symbiosis

Installs the getML library, PyTorch Geometric, pandas, matplotlib, seaborn, numpy, and PyTorch. It also downloads and installs the getML software from a tarball. This setup is crucial for running the subsequent steps in the notebook.

```Python
# You might need to restart the kernel after the installs
%pip install -q "getml==1.5.0" "torch-geometric~=2.5" "pandas~=2.2" "matplotlib~=3.9" "seaborn~=0.13" "numpy~=1.26" "torch~=2.4"

# Download and extract getML software
!wget -q https://static.getml.com/download/1.4.0/getml-1.4.0-x64-linux.tar.gz
!tar -xzf getml-1.4.0-x64-linux.tar.gz >/dev/null 2>&1

# Install getML
!./getml-1.4.0-x64-linux/getML install >/dev/null 2>&1

```

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

### Deploy getML models on Google Cloud Vertex AI

Source: https://getml.com/latest/examples

A step-by-step guide on deploying getML models on Google Cloud Vertex AI. This enables scalable and powerful machine learning workflows on the Google Cloud Platform.

```python
# Example of deploying a getML model to Vertex AI (conceptual)
# This would typically involve packaging the model and using Vertex AI SDK

# from google.cloud import aiplatform
# from getml import getMLModel

# Initialize Vertex AI SDK
# aiplatform.init(project='your-gcp-project', location='your-gcp-region')

# Load your getML model
# model = getMLModel("path/to/your/model")

# Create a Vertex AI Model resource
# model_resource = aiplatform.Model.upload(
#     display_name="getml-model",
#     artifact_uri="gs://your-bucket/your-model-artifacts",
#     serving_container_image_uri="your-custom-serving-image"
# )

# Deploy the model to an endpoint
# endpoint = model_resource.deploy(
#     display_name="getml-endpoint",
#     machine_type="n1-standard-4"
# )
```

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

### Install getML and Dependencies

Source: https://getml.com/latest/examples/enterprise-notebooks/occupancy

Installs the getML library along with matplotlib for plotting and ipywidgets for interactive elements. This is a prerequisite for running the occupancy prediction analysis.

```Python
%pip install -q "getml==1.5.0" "matplotlib==3.9.2" "ipywidgets==8.1.5"

```

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

### Install Python API from Source

Source: https://getml.com/latest/install/source/python-api

This snippet shows the commands to clone the getML Community edition repository, navigate into the directory, and install the Python API using pip.

```bash
# Clone the Community edition
git clone https://github.com/getML/getML.git
# Change directory
cd getML
# Install the Python API
pip3 install .
```

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

### Import getML and Launch Engine

Source: https://getml.com/latest/user_guide/walkthrough

This snippet shows how to import the getML Python API, print the installed version, and launch the getML Engine. The Engine launch is noted as not required for Docker-based installations. Log output for the Engine is stored in a specified file path.

```Python
import getml
print(f"getML API version: {getml.__version__}\n")
getml.engine.launch() #not needed in docker based installations
```

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

### Install Vertex AI SDK

Source: https://getml.com/latest/examples/integrations/vertexai/vertexai

This section covers installing the Vertex AI SDK, which is essential for interacting with Vertex AI services. It also mentions restarting the kernel after installation to ensure the SDK is properly loaded.

```Python
import vertexai

# Initialize Vertex AI
vertexai.init(project="your-project-id", location="your-region")
```

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

### Install getML and Matplotlib

Source: https://getml.com/latest/examples/enterprise-notebooks/loans

Installs the getML library (version 1.5.0) and Matplotlib (version 3.9.2) for data visualization. The '-q' flag ensures a quiet installation process.

```Python
%pip install -q "getml==1.5.0" "matplotlib==3.9.2"
```

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

### Generate Predictions

Source: https://getml.com/latest/user_guide/quick_start

Uses the trained pipeline to generate predictions on new data. The `predict` method takes unseen data and returns the model's predictions.

```Python
pipe.predict(
    population=df_population_unseen,
    peripheral=[df_peripheral_unseen]
)
```

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

### Install Libraries

Source: https://getml.com/latest/examples/enterprise-notebooks/fastprop_benchmark/robot_prop

Installs the necessary Python libraries: getml, featuretools, and tsfresh. This is a prerequisite for running the analysis.

```Python
%pip install -q "getml==1.5.0" "featuretools==1.31.0" "tsfresh==0.20.3"

```

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

### Initialize getML Environment and Plotting

Source: https://getml.com/latest/examples/enterprise-notebooks/occupancy

Imports necessary libraries, including matplotlib for visualization and getML for machine learning tasks. It also configures matplotlib to display plots inline within the environment and prints the installed getML API version.

```Python
import matplotlib.pyplot as plt

import getml

%matplotlib inline

print(f"getML API version: {getml.__version__}\n")

```

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

### Install Dependencies

Source: https://getml.com/latest/examples/enterprise-notebooks/fastprop_benchmark/occupancy_prop

Installs the necessary Python packages for getML, featuretools, and tsfresh. This is a prerequisite for running the analysis in the notebook.

```Python
%pip install -q "getml==1.5.0" "featuretools==1.31.0" "tsfresh==0.20.3"

```

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

### Install getML Vertex AI Package

Source: https://getml.com/latest/examples/integrations/vertexai/vertexai

This code block installs the `getml.vertexai` package, which includes utility functions for GCP resources, configurations for notebooks and containers, and necessary dependencies like getml, google-cloud-aiplatform, and pyyaml. It handles downloading the getml-demo repository and installing the package using uv pip.

```Shell
# type: ignore

if IS_WORKBENCH_ENV:
    # stip-components=1 is necessary to avoid creating a directory with the name of the repository
    ! curl -L https://api.github.com/repos/getml/getml-demo/tarball/vertexai | tar --strip-components=1 -xz
! uv pip install --force-reinstall "."
```

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

### Install getML and Matplotlib, Launch getML Engine

Source: https://getml.com/latest/examples/community-notebooks/robot

Installs the getML library and Matplotlib, then launches the getML Engine and sets the project to 'robot'. This is a prerequisite for running the analysis.

```Python
%pip install -q "getml==1.5.0" "matplotlib~=3.9"

import getml
import matplotlib.pyplot as plt
%matplotlib inline  

getml.engine.launch()
getml.engine.set_project('robot')

```

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

### Install GetML and Dependencies

Source: https://getml.com/latest/examples/enterprise-notebooks/stats

Installs the getml library along with featuretools and ipywidgets using pip. This is a prerequisite for using the getml package.

```Python
%pip install -q "getml==1.5.0" "featuretools==1.31.0" "ipywidgets==8.1.5"
```

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

### Install GetML and Dependencies

Source: https://getml.com/latest/examples/enterprise-notebooks/online_retail

Installs the getml library along with pyspark and ipywidgets using pip. This is a prerequisite for using the getml functionalities.

```Python
%pip install -q "getml==1.5.0" "pyspark==3.5.2" "ipywidgets==8.1.5"
```

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

### Install GetML and Dependencies

Source: https://getml.com/latest/examples/enterprise-notebooks/seznam

Installs the getml library along with featuretools and ipywidgets using pip. This is a prerequisite for using the getml package.

```Python
%pip install -q "getml==1.5.0" "featuretools==1.31.0" "ipywidgets==8.1.5"
```

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

### Install getML and Pandas, Launch getML Engine

Source: https://getml.com/latest/examples/community-notebooks/adventure_works

Installs the getML and Pandas libraries and launches the getML engine. It also sets the project to 'adventure_works'. This is a prerequisite for using getML functionalities.

```Python
%pip install -q "getml==1.5.0" "pandas~=2.2"

import numpy as np
import pandas as pd

import getml

getml.engine.launch()
getml.set_project('adventure_works')
```

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

### Install GetML and Dependencies

Source: https://getml.com/latest/examples/enterprise-notebooks/sfscores

Installs the getml library along with featuretools and ipywidgets using pip. This ensures all necessary components are available for the project.

```Python
%pip install -q "getml==1.5.0" "featuretools==1.31.0" "ipywidgets==8.1.5"
```

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

### Install getML Python API and Engine on Linux

Source: https://getml.com/latest/install

Installs the getML Python API and Engine natively on Linux using the pip package manager. This method is suitable for Linux systems with glibc 2.28 or above.

```Bash
pip install getml
```

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

### Example Usage of getml.data.Container and Subset

Source: https://getml.com/latest/reference/data/subset

This example demonstrates how to create a Container, add metadata, and then use the Container's subsets (train and test) with a pipeline for fitting and scoring. It illustrates the practical application of the Subset dataclass in a machine learning workflow.

```Python
container = getml.data.Container(
    train=population_train,
    test=population_test
)

container.add(
    meta=meta,
    order=order,
    trans=trans
)

# train and test are Subsets.
# They contain population_train
# and population_test respectively,
# as well as their peripheral tables
# meta, order and trans.
my_pipeline.fit(container.train)

my_pipeline.score(container.test)
```

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

### Launch GetML Engine and Set Project

Source: https://getml.com/latest/examples/enterprise-notebooks/kaggle_notebooks/epilepsy_recognition

Launches the GetML engine, which runs in the background to manage data processing and algorithms. It also sets the current project name to 'epilepsy_recognition', creating it if it doesn't exist, and provides a link to the project in the monitor.

```Python
getml.engine.launch()
getml.engine.set_project("epilepsy_recognition")
```

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

### Start getML Engine

Source: https://getml.com/latest/user_guide/concepts/getml_suite

Demonstrates how to launch the getML Engine using the Python API. This is typically the first step before interacting with the getML Suite for data science tasks.

```Python
import getml
getml.engine.launch()
```

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

### Initialize and Manage getML Engine Projects (Python)

Source: https://getml.com/latest/reference/engine/engine

Demonstrates how to start the getML Engine, list existing projects, and set a specific project for use. This is a fundamental step before performing any operations within the getML environment.

```Python
getml.engine.list_projects()
getml.engine.set_project('test')
```

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

### Slice and Retrieve Pipelines

Source: https://getml.com/latest/reference/project/pipelines

Demonstrates how to retrieve a subset of pipelines from the container using slicing. This example shows how to get the first 10 pipelines.

```Python
getml.project.pipelines[:10]
```

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

### GetML Project Setup and Pipeline Construction

Source: https://getml.com/latest/reference/hyperopt/gaussian

This Python code demonstrates how to set up a getml project, load datasets, construct data placeholders with joins, define feature learners (Multirel and Relboost), and build a pipeline that includes these feature learners and a predictor. It showcases the basic structure for using getml's components.

```Python
fromgetmlimport data
fromgetmlimport datasets
fromgetmlimport engine
fromgetmlimport feature_learning
fromgetml.feature_learningimport aggregations
fromgetml.feature_learningimport loss_functions
fromgetmlimport hyperopt
fromgetmlimport pipeline
fromgetmlimport predictors

# ----------------

engine.set_project("examples")

# ----------------

population_table, peripheral_table = datasets.make_numerical()

# ----------------
# Construct placeholders

population_placeholder = data.Placeholder("POPULATION")
peripheral_placeholder = data.Placeholder("PERIPHERAL")
population_placeholder.join(peripheral_placeholder, "join_key", "time_stamp")

# ----------------
# Base model - any parameters not included
# in param_space will be taken from this.

fe1 = feature_learning.Multirel(
    aggregation=[
        aggregations.COUNT,
        aggregations.SUM
    ],
    loss_function=loss_functions.SquareLoss,
    num_features=10,
    share_aggregations=1.0,
    max_length=1,
    num_threads=0
)

# ----------------
# Base model - any parameters not included
# in param_space will be taken from this.

fe2 = feature_learning.Relboost(
    loss_function=loss_functions.SquareLoss,
    num_features=10
)

# ----------------
# Base model - any parameters not included
# in param_space will be taken from this.

predictor = predictors.LinearRegression()

# ----------------

pipe = pipeline.Pipeline(
    population=population_placeholder,
    peripheral=[peripheral_placeholder],
    feature_learners=[fe1, fe2],
    predictors=[predictor]
)

# ----------------
# Build a hyperparameter space.
# We have two feature learners and one
# predictor, so this is how we must
# construct our hyperparameter space.
# If we only wanted to optimize the predictor,

```

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

### Annotate Data with Roles

Source: https://getml.com/latest/user_guide/quick_start

Assigns roles to columns within a DataFrame, such as 'target' or 'join_key', which are crucial for defining the data model and relationships.

```Python
df_population.set_role(cols='target', role=getml.data.role.target)
df_population.set_role(cols='join_key', role=getml.data.role.join_key)
```

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

### Set up Google Cloud Project and Environment

Source: https://getml.com/latest/examples/integrations/vertexai/vertexai

This guide details the steps for setting up your Google Cloud project and determining the appropriate environment for development. It involves enabling necessary APIs and configuring service accounts for authentication and authorization.

```Bash
# Example command to enable Vertex AI API (replace with actual command if available)
gcloud services enable aiplatform.googleapis.com
```

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

### Define Data Model and Relationships

Source: https://getml.com/latest/user_guide/quick_start

Constructs a DataModel by defining placeholder tables and establishing join relationships between them. This step structures the data for feature engineering.

```Python
dm = getml.data.DataModel(population=df_population.to_placeholder())
dm.add(df_peripheral.to_placeholder())
dm.population.join(
   dm.peripheral,
   on="join_key",
)
```

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

### Set and Check Project

Source: https://getml.com/latest/user_guide/walkthrough

Demonstrates how to set a new project in getML and then check the currently active project. It includes the command to set the project and the command to display the current project status, illustrating the connection process.

```Python
getml.engine.set_project("getting_started")
```

```Python
getml.project
```

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

### Get Row Numbers with rowid

Source: https://getml.com/latest/reference/data

The `rowid` function returns a numerical column containing the row identifiers of a table, starting from 0. It returns a FloatColumnView object.

```Python
def rowid() -> FloatColumnView:
    """
        Get the row numbers of the table.

        Returns:
                (numerical) column containing the row id, starting with 0
        """
    return FloatColumnView(operator="rowid", operand1=None, operand2=None)
```

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

### Get Row IDs with rowid

Source: https://getml.com/latest/reference/data/columns

The `rowid` function retrieves the row numbers of a table, starting from 0. It returns a `FloatColumnView` object representing the row identifiers.

```Python
def rowid() -> FloatColumnView:
    """
    Get the row numbers of the table.

    Returns:
            (numerical) column containing the row id, starting with 0
    """
    return FloatColumnView(operator="rowid", operand1=None, operand2=None)
```

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

### GetML Project Setup and Data Loading

Source: https://getml.com/latest/blog/new-algorithms-relational-learning

Initializes a GetML project and loads the loans dataset, separating it into training and testing populations. This sets up the environment for subsequent feature engineering and model training.

```Python
import getml
getml.set_project("young_devs")
population_train, population_test, _, trans, _ = getml.datasets.load_loans()
```

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

### getML CLI Available Commands

Source: https://getml.com/latest/reference/cli/engine

Lists the primary commands available in the getML CLI. These commands cover core functionalities such as running the engine, installation, stopping services, uninstallation, and checking the version.

```bash
Possible commands are:
 run        Runs getML. Type "./getML -h" or "./getML run -h" to display the arguments. "run" is executed by default.
 install    Installs getML.
 stop       Stops a running instance of getML. Type "./getML stop -h" to display the arguments.
 uninstall  Uninstalls getML
 version    Prints the version of getML (getml-VERSION-ARCH-PLATFORM)

```

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

### Evaluate Model Performance

Source: https://getml.com/latest/user_guide/quick_start

Scores the trained pipeline using unseen data. The `score` method calculates performance metrics based on the provided population and peripheral data.

```Python
pipe.score(
    population=df_population_unseen,
    peripheral=[df_peripheral_unseen]
)
```

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

### Create and Train getML Pipeline

Source: https://getml.com/latest/examples/enterprise-notebooks/kaggle_notebooks/epilepsy_recognition

This code demonstrates how to create a getML Pipeline by combining a data model, feature learners, and predictors. It then trains the pipeline using the fit method on the provided training data.

```Python
pipe = getml.pipeline.Pipeline(
    data_model=time_series.data_model,
    tags=["FastProp+AggAll", "XGBoost", f"split={train}/{test}"],
    feature_learners=[feature_learner],
    predictors=[predictor],
)

pipe.fit(time_series.train, check=False)
```

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

### Launch and Configure getML Engine

Source: https://getml.com/latest/examples/enterprise-notebooks/occupancy

Launches the getML engine, allowing remote IP connections and setting a specific project named 'occupancy'. This step is crucial for preparing the getML environment to process the occupancy dataset.

```Python
getml.engine.launch(allow_remote_ips=True, token='token')
getml.engine.set_project("occupancy")

```

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

### Get SQL for Top Feature

Source: https://getml.com/latest/examples/enterprise-notebooks/occupancy

Retrieves the SQL code for the most important feature identified by the pipeline. This allows for inspection of how the feature is constructed in the database.

```Python
pipe.features.to_sql()[names[0]]
```

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

### Get SQL for Second Feature

Source: https://getml.com/latest/examples/enterprise-notebooks/occupancy

Retrieves the SQL code for the second most important feature. This provides insight into the data manipulation and logic used to create this specific feature.

```Python
pipe.features.to_sql()[names[1]]
```

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

### Setup Python Path and Import Utilities

Source: https://getml.com/latest/examples/enterprise-notebooks/fastprop_benchmark/occupancy_prop

This code snippet sets up the Python path to include the parent directory and imports necessary utility classes like Benchmark, FTTimeSeriesBuilder, and TSFreshBuilder from a local 'utils' module. This is often done in environments like Colab to access custom helper functions.

```Python
parent = Path(os.getcwd()).parent.as_posix()

if parent not in sys.path:
    sys.path.append(parent)

fromutilsimport Benchmark, FTTimeSeriesBuilder, TSFreshBuilder
```

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

### Python GetML Environment Setup

Source: https://getml.com/latest/examples/enterprise-notebooks/atherosclerosis

This Python code installs essential libraries for GetML, Featuretools, tsfresh, Matplotlib, and ipywidgets. It then imports Matplotlib and GetML, sets up the inline plotting environment, and prints the GetML API version.

```Python
%pip install -q "getml==1.5.0" "featuretools==1.31.0" "tsfresh==0.20.3" "matplotlib==3.9.2" "ipywidgets==8.1.5"

import matplotlib.pyplot as plt
import getml

%matplotlib inline

print(f"getML API version: {getml.__version__}\n")
```

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

### Integrate getML with FastAPI for REST API

Source: https://getml.com/latest/examples

This guide demonstrates how to integrate getML with FastAPI to create a REST API for machine learning models. It covers setting up a generic prediction endpoint, making getML pipelines accessible via web APIs.

```python
from fastapi import FastAPI
from getml import getMLModel

app = FastAPI()

# Load your getML model
model = getMLModel("path/to/your/model")

@app.post("/predict/")
def predict(data: dict):
    # Process input data and make predictions
    prediction = model.predict(data)
    return {"prediction": prediction}
```

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

### Launch and Configure GetML Engine

Source: https://getml.com/latest/examples/enterprise-notebooks/online_retail

Launches the GetML engine with specified parameters, including allowing remote IPs and setting a project token. It then sets the active project to 'online_retail'.

```Python
getml.engine.launch(allow_remote_ips=True, token='token')
getml.engine.set_project('online_retail')
```

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

### SQL for Feature Generation (Example 1)

Source: https://getml.com/latest/examples/enterprise-notebooks/adventure_works

This SQL code is generated by getML to create a table named 'FEATURE_1_301'. It calculates a feature based on the difference between order dates and start dates, joining two staging tables.

```SQL
DROPTABLEIFEXISTS"FEATURE_1_301";

CREATETABLE"FEATURE_1_301"AS
SELECTMIN(t1."orderdate"-t2."t4__startdate")AS"feature_1_301",
 t1.rowidASrownum
FROM"POPULATION__STAGING_TABLE_1"t1
INNERJOIN"SALES_ORDER_DETAIL__STAGING_TABLE_2"t2
ONt1."salesorderid"=t2."salesorderid"
GROUPBYt1.rowid;
```

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

### Launch GetML Engine and Set Project

Source: https://getml.com/latest/examples/enterprise-notebooks/stats

Launches the GetML engine, allowing remote IP connections and setting the active project to 'stats'. This prepares the environment for data analysis and model training within the specified project.

```Python
getml.engine.launch(allow_remote_ips=True, token='token')
getml.engine.set_project('stats')
```

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

### Setup getML Pipeline Components

Source: https://getml.com/latest/examples/enterprise-notebooks/loans

Configures the necessary components for a getML pipeline, including data preprocessing (Mapping), feature learning (FastProp), and prediction (XGBoostClassifier). It sets parameters like minimum frequency, aggregation methods, loss functions, number of threads, and XGBoost specific parameters like gamma and n_jobs.

```Python
mapping = getml.preprocessors.Mapping(min_freq=100)

fast_prop = getml.feature_learning.FastProp(
    aggregation=getml.feature_learning.FastProp.agg_sets.All,
    loss_function=getml.feature_learning.loss_functions.CrossEntropyLoss,
    num_threads=1,
)

feature_selector = getml.predictors.XGBoostClassifier(n_jobs=1)

# the population is really small, so we set gamma to mitigate overfitting
predictor = getml.predictors.XGBoostClassifier(
    gamma=2,
    n_jobs=1,
)
```

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

### Initialize StarSchema

Source: https://getml.com/latest/reference/data/star_schema

Demonstrates the initialization of the StarSchema class with optional population, alias, peripheral tables, split information, and deep copy settings. It also shows how to pass training, validation, and test datasets separately.

```Python
StarSchema(
    population: Optional[Union[DataFrame, View]] = None,
    alias: Optional[str] = None,
    peripheral: Optional[
        Dict[str, Union[DataFrame, View]]
    ] = None,
    split: Optional[
        Union[StringColumn, StringColumnView]
    ] = None,
    deep_copy: Optional[bool] = False,
    train: Optional[Union[DataFrame, View]] = None,
    validation: Optional[Union[DataFrame, View]] = None,
    test: Optional[Union[DataFrame, View]] = None,
    **kwargs: Optional[Union[DataFrame, View]]
)
```

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

### Multivariate Time Series Prediction with getML

Source: https://getml.com/latest/examples/community-notebooks

This notebook provides an introduction to time series prediction using the 'interstate94' dataset, featuring 24,096 data points. It's a regression task focused on transportation and is considered 'Easy' for getting started with time series analysis.

```Python
interstate94.ipynb Multivariate time series prediction
```

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

### Install getML Community Edition (Linux)

Source: https://getml.com/latest/install/packages/linux

Installs the getML Community edition, including the Python API and Engine, on a Linux machine using pip.

```Shell
pip install getml
```

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

### Launch GetML Engine and Set Project

Source: https://getml.com/latest/examples/enterprise-notebooks/seznam

Launches the GetML engine with specified parameters, including allowing remote IPs and providing a token. It then sets the current project to 'seznam'. The output confirms the engine launch and project connection.

```Python
getml.engine.launch(allow_remote_ips=True, token='token')
getml.set_project('seznam')
```

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

### Install getML Python API using pip

Source: https://getml.com/latest/install/packages/docker

Installs the getML Python API using the pip package manager. This is the primary method for integrating getML into Python projects.

```bash
pip install getml
```

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

### Build and Use a GetML Pipeline

Source: https://getml.com/latest/reference/data/star_schema

Demonstrates how to initialize a GetML Pipeline with data model, preprocessors, feature learners, selectors, and predictors. It covers checking, fitting, and scoring the pipeline with training and testing data, and generating predictions on new data using a Container.

```Python
pipe = getml.Pipeline(
    data_model=star_schema.data_model,
    preprocessors=[mapping],
    feature_learners=[fast_prop],
    feature_selectors=[feature_selector],
    predictors=predictor,
)

pipe.check(star_schema.train)

pipe.fit(star_schema.train)

pipe.score(star_schema.test)

container = getml.data.Container(
    population=population_new)

container.add(
    trans=trans_new,
    order=order_new,
    meta=meta_new)

predictions = pipe.predict(container.full)
```

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

### Get Aggregation Value with get

Source: https://getml.com/latest/reference/data/columns

The `get` method of the `Aggregation` class retrieves the computed value of the aggregation over a column. It sends a command to the engine and returns the resulting float value.

```Python
def get(self):
    """
    Receives the value of the aggregation over the column.
    """

    cmd: Dict[str, Any] = {}

    cmd["name_"] = ""
    cmd["type_"] = "FloatColumn.aggregate"

    cmd["aggregation_"] = self.cmd

    with comm.send_and_get_socket(cmd) as sock:
        msg = comm.recv_string(sock)
        if msg != "Success!":
            comm.handle_engine_exception(msg)
        mat = comm.recv_float_matrix(sock)

    return mat.ravel()[0]
```

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

### Initialize GetML Environment

Source: https://getml.com/latest/examples/enterprise-notebooks/stats

Imports essential Python libraries and configures the environment for GetML. It sets a PyArrow timezone ignore flag and suppresses future warnings, then prints the installed getML API version.

```Python
import os
import warnings

import pandas as pd

import featuretools
import woodwork as ww
import getml

os.environ["PYARROW_IGNORE_TIMEZONE"] = "1"
warnings.simplefilter(action='ignore', category=FutureWarning)

print(f"getML API version: {getml.__version__}\n")
```

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

### Install GetML and Dependencies

Source: https://getml.com/latest/examples/enterprise-notebooks/consumer_expenditures

Installs the getml library along with matplotlib and ipywidgets for data visualization and interactive elements. The '-q' flag ensures quiet installation.

```Python
%pip install -q "getml==1.5.0" "matplotlib==3.9.2" "ipywidgets==8.1.5"

```

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

### Python: Example of using Container with subsets

Source: https://getml.com/latest/reference/data/container

Demonstrates how to create a Container by passing specific subsets like 'train' and 'test'. It also shows how to access custom subsets defined via keyword arguments.

```Python
# Pass the subset.
container = getml.data.Container(my_subset=my_data_frame)

# You can access the subset just like train,
# validation or test
my_pipeline.fit(container.my_subset)
```

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

### Install GetML and Dependencies

Source: https://getml.com/latest/examples/enterprise-notebooks/kaggle_notebooks/getml-and-gnns-a-natural-symbiosis

Installs the GetML library along with PyTorch Geometric, Pandas, Matplotlib, Seaborn, and NumPy using pip. It also downloads and extracts the GetML software and installs it.

```bash
%pip install -q "getml==1.5.0" "torch-geometric~=2.5" "pandas~=2.2" "matplotlib~=3.9" "seaborn~=0.13" "numpy~=1.26" "torch~=2.4"
!wget -q https://static.getml.com/download/1.4.0/getml-1.4.0-x64-linux.tar.gz
!tar -xzf getml-1.4.0-x64-linux.tar.gz >/dev/null 2>&1
!./getml-1.4.0-x64-linux/getML install >/dev/null 2>&1
```

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

### Deploy getML with Docker Compose

Source: https://getml.com/latest/blog/deploy-with-docker-compose

This snippet demonstrates the command to download and use a Docker Compose file for deploying the getML engine. It requires Docker to be installed and allows for seamless communication with the getML Python API.

```Shell
curl -o docker-compose.yml https://getml.ai/1.5.0/runtime/docker-compose.yml
```

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

### Install getml-mlflow Package

Source: https://getml.com/latest/user_guide/concepts/mlflow_integration

Installs the getml-mlflow package using pip, which is necessary for integrating MLflow tracking with getML. It also shows how to install the latest development version directly from GitHub.

```Shell
pip install getml-mlflow

```

```Shell
pip"git+ssh://git@github.com/getml/getml-mlflow.git"

```

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

### Install getML and Plotting Libraries (Python)

Source: https://getml.com/latest/examples/enterprise-notebooks/robot

Installs the getML library along with matplotlib and ipywidgets for data visualization and interactive elements. The '-q' flag ensures a quiet installation process.

```Python
%pip install -q "getml==1.5.0" "matplotlib==3.9.2" "ipywidgets==8.1.5"
```

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

### RandomSearch Example Usage

Source: https://getml.com/latest/reference/hyperopt/random

Demonstrates how to set up a getML project, load data, define placeholders for data joining, and construct a base feature learning model for hyperparameter optimization using RandomSearch.

```Python
fromgetmlimport data
fromgetmlimport datasets
fromgetmlimport engine
fromgetmlimport feature_learning
fromgetml.feature_learningimport aggregations
fromgetml.feature_learningimport loss_functions
fromgetmlimport hyperopt
fromgetmlimport pipeline
fromgetmlimport predictors

# ----------------

engine.set_project("examples")

# ----------------

population_table, peripheral_table = datasets.make_numerical()

# ----------------
# Construct placeholders

population_placeholder = data.Placeholder("POPULATION")
peripheral_placeholder = data.Placeholder("PERIPHERAL")
population_placeholder.join(peripheral_placeholder, "join_key", "time_stamp")

# ----------------
# Base model - any parameters not included
# in param_space will be taken from this.

fe1 = feature_learning.Multirel(
    aggregation=[
        aggregations.COUNT,
        aggregations.SUM
    ],
    loss_function=loss_functions.SquareLoss,
    num_features=10,
    share_aggregations=1.0,
    max_length=1,
    num_threads=0
)

# ----------------
# Base model - any parameters not included
```

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

### Install getML, featuretools, and tsfresh

Source: https://getml.com/latest/examples/enterprise-notebooks/fastprop_benchmark/air_pollution_prop

Installs the necessary Python libraries for the demonstration: getML, featuretools, and tsfresh. It's recommended to restart the kernel after installation for the packages to be recognized.

```Python
%pip install -q "getml==1.5.0" "featuretools==1.31.0" "tsfresh==0.20.3"


```

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

### Launch getML Engine and Set Project

Source: https://getml.com/latest/examples/enterprise-notebooks/loans

Launches the getML engine with specified parameters, including allowing remote IP connections and providing an authentication token. It then sets the active project within the getML environment to 'loans'.

```Python
getml.engine.launch(allow_remote_ips=True, token="token")
getml.engine.set_project("loans")
```

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

### Install getML and Featuretools

Source: https://getml.com/latest/examples/enterprise-notebooks/fastprop_benchmark/interstate94_prop

Installs the getML and featuretools Python libraries with specific versions. This is a prerequisite for running the analysis in the notebook. It uses pip for installation and the '-q' flag for quiet operation.

```Python
%pip install -q "getml==1.5.0" "featuretools==1.31.0"

%pip install -q "getml==1.5.0" "featuretools==1.31.0"

```

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

### Install getML and Dependencies

Source: https://getml.com/latest/examples/enterprise-notebooks/kaggle_notebooks/cora_getml_vs_gnn

Installs the getML library, PyTorch Geometric, pandas, matplotlib, seaborn, numpy, and PyTorch. It also downloads and installs the getML software for Linux.

```Python
# You might need to restart the kernel after the installs
%pip install -q "getml==1.5.0" "torch-geometric~=2.5" "pandas~=2.2" "matplotlib~=3.9" "seaborn~=0.13" "numpy~=1.26" "torch~=2.4"

# Download and extract getML software
!wget -q https://static.getml.com/download/1.4.0/getml-1.4.0-x64-linux.tar.gz
!tar -xzf getml-1.4.0-x64-linux.tar.gz >/dev/null 2>&1

# Install getML
!./getml-1.4.0-x64-linux/getML install >/dev/null 2>&1

```
Tokens:
Raw