Models

class mindsdb_sdk.models.Model(project, data)

Bases: object

Versions

List model versions

>>> model.list_versions()

Get info

>>> print(model.get_status())
>>> print(model.data)

Update model data from server

>>> model.refresh()

Usng model

Dataframe on input

>>> result_df = model.predict(df_rental)
>>> result_df = model.predict(df_rental, params={'a': 'q'})

Dict on input

>>> result_df = model.predict({'n_rooms': 2})

Deferred query on input

>>> result_df = model.predict(query, params={'': ''})

Time series prediction

>>> query = database.query('select * from table1 where type="house" and saledate>latest')
>>> model.predict(query)

The join model with table in raw query

>>> result_df = project.query('''
...  SELECT m.saledate as date, m.ma as forecast
...   FROM mindsdb.house_sales_model as m
...   JOIN example_db.demo_data.house_sales as t
...  WHERE t.saledate > LATEST AND t.type = 'house'
...   AND t.bedrooms=2
...  LIMIT 4;
...''').fetch()

Model managing

Fine-tuning

>>> model.finetune(query)
>>> model.finetune('select * from demo_data.house_sales', database='example_db')
>>> model.finetune(query, params={'x': 2})

Retraining

>>> model.retrain(query)
>>> model.retrain('select * from demo_data.house_sales', database='example_db')
>>> model.retrain(query, params={'x': 2})

Describe

>>> df_info = model.describe()
>>> df_info = model.describe('features')

Change active version

>>> model.set_active(version=3)
describe(type: Optional[str] = None) → Union[pandas.core.frame.DataFrame, mindsdb_sdk.query.Query]

Return description of the model

Parameters

type – describe type (for lightwood is models, ensemble, features), optional

Returns

dataframe with result of description

drop_version(num: int) → mindsdb_sdk.models.ModelVersion

Drop version of the model

>>> models.rentals_model.drop_version(version=10)
Parameters

num – version to drop

finetune(query: Union[str, mindsdb_sdk.query.Query, None] = None, database: Optional[str] = None, options: Optional[dict] = None, engine: Optional[str] = None) → Union[mindsdb_sdk.models.Model, mindsdb_sdk.models.ModelVersion]

Call finetune of the model

Parameters

  • query – sql string or Query object to get data for fine-tuning, optional

  • database – database to get data for fine-tuning, optional

  • options – parameters for fine-tuning model, optional

  • engine – ml engine, optional

Returns

Model object

get_status() → str

Refresh model data and return status of model

Returns

model status

get_version(num: int) → mindsdb_sdk.models.ModelVersion

Get model version by number

Parameters

num – version number

Returns

ModelVersion object

list_versions() → List[mindsdb_sdk.models.ModelVersion]

Show list of model versions

Returns

list ModelVersion objects

predict(data: Union[pandas.core.frame.DataFrame, mindsdb_sdk.query.Query, dict], params: Optional[dict] = None) → Union[pandas.core.frame.DataFrame, mindsdb_sdk.query.Query]

Make prediction using model

if data is dataframe

it uses /model/predict http method and sends dataframe over it

if data is select query with one table

it replaces table to jon table and predictor and sends query over sql/query http method

if data is select from join other complex query it modifies query to:

‘select from (input query) join model’ and sends it over sql/query http method

Parameters

  • data – dataframe or Query object as input to predictor

  • params – parameters for predictor, optional

Returns

dataframe with result of prediction

refresh()

Refresh model data from mindsdb server Model data can be changed during training process

Returns

model data

retrain(query: Union[str, mindsdb_sdk.query.Query, None] = None, database: Optional[str] = None, options: Optional[dict] = None, engine: Optional[str] = None) → Union[mindsdb_sdk.models.Model, mindsdb_sdk.models.ModelVersion]

Call retrain of the model

Parameters

  • query – sql string or Query object to get data for retraining, optional

  • database – database to get data for retraining, optional

  • options – parameters for retraining model, optional

  • engine – ml engine, optional

Returns

Model object

set_active(version: int)

Change model active version

Parameters

version – version to set active

wait_complete()
class mindsdb_sdk.models.ModelVersion(project, data)

Bases: mindsdb_sdk.models.Model

class mindsdb_sdk.models.Models(project, api)

Bases: mindsdb_sdk.utils.objects_collection.CollectionBase

Models

Get:

>>> all_models = models.list()
>>> model = all_models[0]

Get version:

>>> all_models = models.list(with_versions=True)
>>> model = all_models[0]

By name:

>>> model = models.get('model1')
>>> model = models.get('model1', version=2)
create(name: str, predict: Optional[str] = None, engine: Union[str, mindsdb_sdk.ml_engines.MLEngine, None] = None, query: Union[str, mindsdb_sdk.query.Query, None] = None, database: Optional[str] = None, options: Optional[dict] = None, timeseries_options: Optional[dict] = None, **kwargs) → Union[mindsdb_sdk.models.Model, mindsdb_sdk.query.Query]

Create new model in project and return it

If query/database is passed, it will be executed on mindsdb side

Create, using params and qeury as string

>>> model = models.create(
...   'rentals_model',
...   predict='price',
...   engine='lightwood',
...   database='example_db',
...   query='select * from table',
...   options={
...       'module': 'LightGBM'
...   },
...   timeseries_options={
...       'order': 'date',
...       'group': ['a', 'b']
...   }
...)

Create, using deferred query. ‘query’ will be executed and converted to dataframe on mindsdb backend.

>>> query = databases.db.query('select * from table')
>>> model = models.create(
...   'rentals_model',
...   predict='price',
...   query=query,
...)
Parameters

  • name – name of the model

  • predict – prediction target

  • engine – ml engine for new model, default is mindsdb

  • query – sql string or Query object to get data for training of model, optional

  • database – database to get data for training, optional

  • options – parameters for model, optional

  • timeseries_options – parameters for forecasting model

Returns

created Model object, it can be still in training state

drop(name: str)

Drop model from project with all versions

>>> models.drop('rentals_model')
Parameters

name – name of the model

get(name: str, version: Optional[int] = None) → Union[mindsdb_sdk.models.Model, mindsdb_sdk.models.ModelVersion]

Get model by name from project

if version is passed it returns ModelVersion object with specific version

Parameters

  • name – name of the model

  • version – version of model, optional

Returns

Model or ModelVersion object

list(with_versions: bool = False, name: Optional[str] = None, version: Optional[int] = None) → List[Union[mindsdb_sdk.models.Model, mindsdb_sdk.models.ModelVersion]]

List models (or model versions) in project

If with_versions = True

it shows all models with version (executes ‘select * from models_versions’)

Otherwise it shows only models (executes ‘select * from models’)

Parameters

  • with_versions – show model versions

  • name – to show models or versions only with selected name, optional

  • version – to show model or versions only with selected version, optional

Returns

list of Model or ModelVersion objects