bigml 9.8.3
An open source binding to BigML.io, the public BigML API
License: http://www.apache.org/licenses/LICENSE-2.0

BigML Python Bindings
=====================

`BigML <https://bigml.com>`_ makes machine learning easy by taking care
of the details required to add data-driven decisions and predictive
power to your company. Unlike other machine learning services, BigML
creates
`beautiful predictive models <https://bigml.com/gallery/models>`_ that
can be easily understood and interacted with.

These BigML Python bindings allow you to interact with
`BigML.io <https://bigml.io/>`_, the API
for BigML. You can use it to easily create, retrieve, list, update, and
delete BigML resources (i.e., sources, datasets, models and,
predictions). For additional information, see
the `full documentation for the Python
bindings on Read the Docs <http://bigml.readthedocs.org>`_.

This module is licensed under the `Apache License, Version
2.0 <http://www.apache.org/licenses/LICENSE-2.0.html>`_.

Support
-------

Please report problems and bugs to our `BigML.io issue
tracker <https://github.com/bigmlcom/io/issues>`_.

Discussions about the different bindings take place in the general
`BigML mailing list <http://groups.google.com/group/bigml>`_. Or join us
in our `Campfire chatroom <https://bigmlinc.campfirenow.com/f20a0>`_.

Requirements
------------

Only ``Python 3`` versions are currently supported by these bindings.
Support for Python 2.7.X ended in version ``4.32.3``.

The basic third-party dependencies are the
`requests <https://github.com/kennethreitz/requests>`_,
`unidecode <http://pypi.python.org/pypi/Unidecode/#downloads>`_,
`requests-toolbelt <https://pypi.python.org/pypi/requests-toolbelt>`_,
`bigml-chronos <https://pypi.org/project/bigml-chronos>`_,
`msgpack <https://pypi.org/project/msgpack>`_,
`numpy <http://www.numpy.org/>`_ and
`scipy <http://www.scipy.org/>`_ libraries. These
libraries are automatically installed during the basic setup.
Support for Google App Engine has been added as of version 3.0.0,
using the `urlfetch` package instead of `requests`.

The bindings will also use ``simplejson`` if you happen to have it
installed, but that is optional: we fall back to Python's built-in JSON
libraries is ``simplejson`` is not found.

The bindings provide support to use the ``BigML`` platform to create, update,
get and delete resources, but also to produce local predictions using the
models created in ``BigML``. Most of them will be actionable with the basic
installation, but some additional dependencies are needed to use local
``Topic Models`` and Image Processing models. Please, refer to the
`Installation <#installation>`_ section for details.

OS Requirements
~~~~~~~~~~~~~~~

The basic installation of the bindings is compatible and can be used
on Linux and Windows based Operating Systems.
However, the extra options that allow working with
image processing models (``[images]`` and ``[full]``) are only supported
and tested on Linux-based Operating Systems.
For image models, Windows OS is not recommended and cannot be supported out of
the box, because the specific compiler versions or dlls required are
unavailable in general.

Installation
------------

To install the basic latest stable release with
`pip <http://www.pip-installer.org/>`_, please use:

.. code-block:: bash

    $ pip install bigml

Support for local Topic Distributions (Topic Models' predictions)
and local predictions for datasets that include Images will only be
available as extras, because the libraries used for that are not
usually available in all Operative Systems. If you need to support those,
please check the `Installation Extras <#installation-extras>`_ section.

Installation Extras
-------------------

Local Topic Distributions support can be installed using:

.. code-block:: bash

    pip install bigml[topics]

Images local predictions support can be installed using:

.. code-block:: bash

    pip install bigml[images]

The full set of features can be installed using:

.. code-block:: bash

    pip install bigml[full]


WARNING: Mind that installing these extras can require some extra work, as
explained in the `Requirements <#requirements>`_ section.

You can also install the development version of the bindings directly
from the Git repository

.. code-block:: bash

    $ pip install -e git://github.com/bigmlcom/python.git#egg=bigml_python


Running the Tests
-----------------

The tests will be run using `pytest <https://docs.pytest.org/en/7.2.x/>`_.
You'll need to set up your authentication
via environment variables, as explained
in the authentication section. Also some of the tests need other environment
variables like ``BIGML_ORGANIZATION`` to test calls when used by Organization
members and ``BIGML_EXTERNAL_CONN_HOST``, ``BIGML_EXTERNAL_CONN_PORT``,
``BIGML_EXTERNAL_CONN_DB``, ``BIGML_EXTERNAL_CONN_USER``,
``BIGML_EXTERNAL_CONN_PWD`` and ``BIGML_EXTERNAL_CONN_SOURCE``
in order to test external data connectors.

With that in place, you can run the test suite simply by issuing

.. code-block:: bash

    $ pytest

Additionally, `Tox <http://tox.testrun.org/>`_ can be used to
automatically run the test suite in virtual environments for all
supported Python versions.  To install Tox:

.. code-block:: bash

    $ pip install tox

Then run the tests from the top-level project directory:

.. code-block:: bash

    $ tox

Importing the module
--------------------

To import the module:

.. code-block:: python

    import bigml.api

Alternatively you can just import the BigML class:

.. code-block:: python

    from bigml.api import BigML

Authentication
--------------

All the requests to BigML.io must be authenticated using your username
and `API key <https://bigml.com/account/apikey>`_ and are always
transmitted over HTTPS.

This module will look for your username and API key in the environment
variables ``BIGML_USERNAME`` and ``BIGML_API_KEY`` respectively.

Unix and MacOS
--------------

You can
add the following lines to your ``.bashrc`` or ``.bash_profile`` to set
those variables automatically when you log in:

.. code-block:: bash

    export BIGML_USERNAME=myusername
    export BIGML_API_KEY=ae579e7e53fb9abd646a6ff8aa99d4afe83ac291

refer to the next chapters to know how to do that in other operating systems.

With that environment set up, connecting to BigML is a breeze:

.. code-block:: python

    from bigml.api import BigML
    api = BigML()

Otherwise, you can initialize directly when instantiating the BigML
class as follows:

.. code-block:: python

    api = BigML('myusername', 'ae579e7e53fb9abd646a6ff8aa99d4afe83ac291')

These credentials will allow you to manage any resource in your user
environment.

In BigML a user can also work for an ``organization``.
In this case, the organization administrator should previously assign
permissions for the user to access one or several particular projects
in the organization.
Once permissions are granted, the user can work with resources in a project
according to his permission level by creating a special constructor for
each project. The connection constructor in this case
should include the ``project ID``:

.. code-block:: python

    api = BigML('myusername', 'ae579e7e53fb9abd646a6ff8aa99d4afe83ac291',
                project='project/53739b98d994972da7001d4a')

If the project used in a connection object
does not belong to an existing organization but is one of the
projects under the user's account, all the resources
created or updated with that connection will also be assigned to the
specified project.

When the resource to be managed is a ``project`` itself, the connection
needs to include the corresponding``organization ID``:

.. code-block:: python

    api = BigML('myusername', 'ae579e7e53fb9abd646a6ff8aa99d4afe83ac291',
                organization='organization/53739b98d994972da7025d4a')


Authentication on Windows
-------------------------

The credentials should be permanently stored in your system using

.. code-block:: bash

    setx BIGML_USERNAME myusername
    setx BIGML_API_KEY ae579e7e53fb9abd646a6ff8aa99d4afe83ac291

Note that ``setx`` will not change the environment variables of your actual
console, so you will need to open a new one to start using them.


Authentication on Jupyter Notebook
----------------------------------

You can set the environment variables using the ``%env`` command in your
cells:

.. code-block:: bash

    %env BIGML_USERNAME=myusername
    %env BIGML_API_KEY=ae579e7e53fb9abd646a6ff8aa99d4afe83ac291


Alternative domains
-------------------


The main public domain for the API service is ``bigml.io``, but there are some
alternative domains, either for Virtual Private Cloud setups or
the australian subdomain (``au.bigml.io``). You can change the remote
server domain
to the VPC particular one by either setting the ``BIGML_DOMAIN`` environment
variable to your VPC subdomain:

.. code-block:: bash

    export BIGML_DOMAIN=my_VPC.bigml.io

or setting it when instantiating your connection:

.. code-block:: python

    api = BigML(domain="my_VPC.bigml.io")

The corresponding SSL REST calls will be directed to your private domain
henceforth.

You can also set up your connection to use a particular PredictServer
only for predictions. In order to do so, you'll need to specify a ``Domain``
object, where you can set up the general domain name as well as the
particular prediction domain name.

.. code-block:: python

    from bigml.domain import Domain
    from bigml.api import BigML

    domain_info = Domain(prediction_domain="my_prediction_server.bigml.com",
                         prediction_protocol="http")

    api = BigML(domain=domain_info)

Finally, you can combine all the options and change both the general domain
server, and the prediction domain server.

.. code-block:: python

    from bigml.domain import Domain
    from bigml.api import BigML
    domain_info = Domain(domain="my_VPC.bigml.io",
                         prediction_domain="my_prediction_server.bigml.com",
                         prediction_protocol="https")

    api = BigML(domain=domain_info)

Some arguments for the Domain constructor are more unsual, but they can also
be used to set your special service endpoints:

- protocol (string) Protocol for the service
  (when different from HTTPS)
- verify (boolean) Sets on/off the SSL verification
- prediction_verify (boolean) Sets on/off the SSL verification
  for the prediction server (when different from the general
  SSL verification)

**Note** that the previously existing ``dev_mode`` flag:

.. code-block:: python

    api = BigML(dev_mode=True)

that caused the connection to work with the Sandbox ``Development Environment``
has been **deprecated** because this environment does not longer exist.
The existing resources that were previously
created in this environment have been moved
to a special project in the now unique ``Production Environment``, so this
flag is no longer needed to work with them.


Quick Start
-----------

Imagine that you want to use `this csv
file <https://static.bigml.com/csv/iris.csv>`_ containing the `Iris
flower dataset <http://en.wikipedia.org/wiki/Iris_flower_data_set>`_ to
predict the species of a flower whose ``petal length`` is ``2.45`` and
whose ``petal width`` is ``1.75``. A preview of the dataset is shown
below. It has 4 numeric fields: ``sepal length``, ``sepal width``,
``petal length``, ``petal width`` and a categorical field: ``species``.
By default, BigML considers the last field in the dataset as the
objective field (i.e., the field that you want to generate predictions
for).

::

    sepal length,sepal width,petal length,petal width,species
    5.1,3.5,1.4,0.2,Iris-setosa
    4.9,3.0,1.4,0.2,Iris-setosa
    4.7,3.2,1.3,0.2,Iris-setosa
    ...
    5.8,2.7,3.9,1.2,Iris-versicolor
    6.0,2.7,5.1,1.6,Iris-versicolor
    5.4,3.0,4.5,1.5,Iris-versicolor
    ...
    6.8,3.0,5.5,2.1,Iris-virginica
    5.7,2.5,5.0,2.0,Iris-virginica
    5.8,2.8,5.1,2.4,Iris-virginica

You can easily generate a prediction following these steps:

.. code-block:: python

    from bigml.api import BigML

    api = BigML()

    source = api.create_source('./data/iris.csv')
    dataset = api.create_dataset(source)
    model = api.create_model(dataset)
    prediction = api.create_prediction(model, \
        {"petal width": 1.75, "petal length": 2.45})

You can then print the prediction using the ``pprint`` method:

.. code-block:: python

    >>> api.pprint(prediction)
    species for {"petal width": 1.75, "petal length": 2.45} is Iris-setosa

Certainly, any of the resources created in BigML can be configured using
several arguments described in the `API documentation <https://bigml.com/api>`_.
Any of these configuration arguments can be added to the ``create`` method
as a dictionary in the last optional argument of the calls:

.. code-block:: python

    from bigml.api import BigML

    api = BigML()

    source_args = {"name": "my source",
         "source_parser": {"missing_tokens": ["NULL"]}}
    source = api.create_source('./data/iris.csv', source_args)
    dataset_args = {"name": "my dataset"}
    dataset = api.create_dataset(source, dataset_args)
    model_args = {"objective_field": "species"}
    model = api.create_model(dataset, model_args)
    prediction_args = {"name": "my prediction"}
    prediction = api.create_prediction(model, \
        {"petal width": 1.75, "petal length": 2.45},
        prediction_args)

The ``iris`` dataset has a small number of instances, and usually will be
instantly created, so the ``api.create_`` calls will probably return the
finished resources outright. As BigML's API is asynchronous,
in general you will need to ensure
that objects are finished before using them by using ``api.ok``.

.. code-block:: python

    from bigml.api import BigML

    api = BigML()

    source = api.create_source('./data/iris.csv')
    api.ok(source)
    dataset = api.create_dataset(source)
    api.ok(dataset)
    model = api.create_model(dataset)
    api.ok(model)
    prediction = api.create_prediction(model, \
        {"petal width": 1.75, "petal length": 2.45})

Note that the prediction
call is not followed by the ``api.ok`` method. Predictions are so quick to be
generated that, unlike the
rest of resouces, will be generated synchronously as a finished object.

The example assumes that your objective field (the one you want to predict)
is the last field in the dataset. If that's not he case, you can explicitly
set the name of this field in the creation call using the ``objective_field``
argument:


.. code-block:: python

    from bigml.api import BigML

    api = BigML()

    source = api.create_source('./data/iris.csv')
    api.ok(source)
    dataset = api.create_dataset(source)
    api.ok(dataset)
    model = api.create_model(dataset, {"objective_field": "species"})
    api.ok(model)
    prediction = api.create_prediction(model, \
        {'sepal length': 5, 'sepal width': 2.5})


You can also generate an evaluation for the model by using:

.. code-block:: python

    test_source = api.create_source('./data/test_iris.csv')
    api.ok(test_source)
    test_dataset = api.create_dataset(test_source)
    api.ok(test_dataset)
    evaluation = api.create_evaluation(model, test_dataset)
    api.ok(evaluation)

If you set the ``storage`` argument in the ``api`` instantiation:

.. code-block:: python

    api = BigML(storage='./storage')

all the generated, updated or retrieved resources will be automatically
saved to the chosen directory.

Alternatively, you can use the ``export`` method to explicitly
download the JSON information
that describes any of your resources in BigML to a particular file:

.. code-block:: python

    api.export('model/5acea49a08b07e14b9001068',
               filename="my_dir/my_model.json")

This example downloads the JSON for the model and stores it in
the ``my_dir/my_model.json`` file.

In the case of models that can be represented in a `PMML` syntax, the
export method can be used to produce the corresponding `PMML` file.

.. code-block:: python

    api.export('model/5acea49a08b07e14b9001068',
               filename="my_dir/my_model.pmml",
               pmml=True)

You can also retrieve the last resource with some previously given tag:

.. code-block:: python

     api.export_last("foo",
                     resource_type="ensemble",
                     filename="my_dir/my_ensemble.json")

which selects the last ensemble that has a ``foo`` tag. This mechanism can
be specially useful when retrieving retrained models that have been created
with a shared unique keyword as tag.

For a descriptive overview of the steps that you will usually need to
follow to model
your data and obtain predictions, please see the `basic Workflow sketch
<api_sketch.html>`_
document. You can also check other simple examples in the following documents:

- `model 101 <101_model.html>`_
- `logistic regression 101 <101_logistic_regression.html>`_
- `linear regression 101 <101_linear_regression.html>`_
- `ensemble 101 <101_ensemble.html>`_
- `cluster 101 <101_cluster>`_
- `anomaly detector 101 <101_anomaly.html>`_
- `association 101 <101_association.html>`_
- `topic model 101 <101_topic_model.html>`_
- `deepnet 101 <101_deepnet.html>`_
- `time series 101 <101_ts.html>`_
- `fusion 101 <101_fusion.html>`_
- `scripting 101 <101_scripting.html>`_

Additional Information
----------------------

We've just barely scratched the surface. For additional information, see
the `full documentation for the Python
bindings on Read the Docs <http://bigml.readthedocs.org>`_.
Alternatively, the same documentation can be built from a local checkout
of the source by installing `Sphinx <http://sphinx.pocoo.org>`_
(``$ pip install sphinx``) and then running

.. code-block:: bash

    $ cd docs
    $ make html

Then launch ``docs/_build/html/index.html`` in your browser.

How to Contribute
-----------------

Please follow the next steps:

  1. Fork the project on github.com.
  2. Create a new branch.
  3. Commit changes to the new branch.
  4. Send a `pull request <https://github.com/bigmlcom/python/pulls>`_.


For details on the underlying API, see the
`BigML API documentation <https://bigml.com/developers>`_.


.. :changelog:

History
-------

9.8.3 (2025-03-27)
------------------

- Fixing annotations update for regions as lists.

9.8.2 (2025-03-21)
------------------

- Retrying annotations update to avoid temporary concurrency issues in
  source composites updates.

9.8.1 (2025-01-14)
------------------

- Fixing annotations update in images composite sources.

9.8.0 (2024-10-02)
------------------

- Fixing the get_leaves function for local decision trees.
- Fixing setup issues in Python3.12
- Changing documentation templates.

9.8.0.dev1 (2024-02-28)
-----------------------

- Documenting and removing partially the need for Node.js in Pipelines.

9.8.0.dev (2024-02-19)
----------------------

- Upgrading libraries to avoid failures in Apple M1 machines.
- Fixing local predictions input data preprocessing for missings.

9.7.1 (2023-12-08)
------------------

- Fixing readthedocs configuration.

9.7.0 (2023-12-06)
------------------

- Changing query string separator in internall API calls.

9.6.2 (2023-08-02)
------------------

- Extending cloning to all available models and WhizzML scripts.
- Fixing shared resources cloning.

9.6.1 (2023-08-01)
------------------

- Adding shared resources cloning.

9.6.0 (2023-07-20)
------------------

- Adding ShapWrapper to enable local Shap values computation with the Shap
  library.
- Adding Evaluation object.
- Improving Field class to allow field values encoding as numpy arrays.

9.5.0 (2023-06-16)
------------------

- Extending Local Fusions output to include confidence.

9.4.0 (2023-06-14)
------------------

- Extending LocalModel class to handle Time Series locally.

9.3.0 (2023-06-09)
------------------

- Adding a LocalModel class to handle any type of BigML model locally.

9.2.0 (2023-04-11)
------------------

- Extending all delete methods to allow additional query strings.

9.1.4 (2023-02-10)
------------------

- Providing local deepnet predictions default for Windows OS that cannot
  handle images predictions.

9.1.3 (2022-12-22)
------------------

- Changing user's status endpoint retrieval to a lightweight version.

9.1.2 (2022-11-26)
------------------

- Removing all nose dependencies in tests.

9.1.1 (2022-11-18)
------------------

- Removing traces and refactoring Flatline interpreter invocation.
- Migrating tests to pytest.

9.1.0 (2022-11-09)
------------------

- Enabling local models to generate the transformations pipeline used in
  training to be able to apply it locally to input data for predictions.
- Refactoring local models to bring the feature extraction capabilities to
  the transformations pipeline.
- Rounding local numeric predictions and scores to 5 digits.
- Improving Pipelines and Image Processing documentation.

9.0.1 (2022-11-02)
------------------

- Fixing local batch_prediction method on DataFrames.
- Improving the training examples method in the Fields class to produce
  examples of categorical field values following their original distribution.

9.0.0 (2022-10-12)
------------------

- Renaming Pipeline class to BMLPipeline and refactoring to allow scikit-learn
  and Pandas pipelines to be also part of the Pipeline transformations.
- Adding several DataTransformers (BMLDataTransformer, SKDataTransformer and
  DFDataTransformer) as wrappers for transformation generators.

8.2.3 (2022-10-07)
------------------

- Fixing dump methods for all local resources.
- Refactoring output options in batch_predict methods.
- Adding name and description to local resources.

8.2.2 (2022-09-29)
------------------

- Fixing locale check.
- Documenting the new ``.batch_predict`` method added to local models to
  homogenize local batch predictions and accept Pandas' DataFrame as input.

8.2.1 (2022-09-23)
------------------

- Fixing update annotations function when creating annotated images sources.

8.2.0 (2022-09-22)
------------------

- Adding new option to api.ok to report progress via a function callback.

8.1.1 (2022-09-21)
------------------

- Fixing bug in api.ok: response to failing API calls.

8.1.0 (2022-09-16)
------------------

- Upgrading dependencies.

8.0.0 (2022-09-13)
------------------

- Adding new local Pipeline object to encapsulate and run prediction
  workflows.
- Changing ``api.ok`` response to return as False when retrieving faulty
  resources. Previously, only problems retrieving the API response cause
  ``api.ok`` returning False.
- Adding FaultyResource exception to inform about that type of failure when
  using the ``raise_on_error`` flag in ``api.ok``.
- Fixing bug in local LogisticRegression when predicting with operating points.

7.7.0 (2022-08-30)
~~~~~~~~~~~~~~~~~~

- Adding local Dataset class to handle Flatline transformations.

7.6.0 (2022-08-18)
~~~~~~~~~~~~~~~~~~

- Adding feature expansion to image fields in local predictors.

7.5.1 (2022-08-08)
~~~~~~~~~~~~~~~~~~

- Adding utility to reproduce the backend images preprocess in local
  deepnets.

7.5.0 (2022-07-09)
~~~~~~~~~~~~~~~~~~

- Adding the new capabilities the last API release: object detection.

7.4.2 (2022-05-26)
~~~~~~~~~~~~~~~~~~

- Improved webhooks hashing check.
- Adapting connection to allow API version setting, needed for compatibility
  with the Predict Server syntax.

7.4.1 (2022-05-16)
~~~~~~~~~~~~~~~~~~

- Adding support for webhooks hashing check.

7.4.0 (2022-05-13)
~~~~~~~~~~~~~~~~~~

- Adding extras to setup, to allow a basic installation and extra dependencies
  handling for topics and images.

7.3.0 (2022-04-22)
~~~~~~~~~~~~~~~~~~

- Improving local ensembles to be generated from list of ensemble plus
  models info.
- Allowing BigML connection class to retrieve models from storage without
  any credentials.

7.2.2 (2022-04-20)
~~~~~~~~~~~~~~~~~~

- Enabling dump from SupervisedModel class.


7.2.1 (2022-04-19)
~~~~~~~~~~~~~~~~~~

- Fixing windows setup.

7.2.0 (2022-04-14)
~~~~~~~~~~~~~~~~~~

- Upgrading sensenet library and giving fallback for local deepnet predictions
  on OS not supported by tensorflow.
- Adding support for pandas' DataFrame when creating sources.

7.1.2 (2022-03-17)
~~~~~~~~~~~~~~~~~~

- Fixing local deepnet predictions if no missing_count info is found.

7.1.1 (2022-03-11)
~~~~~~~~~~~~~~~~~~

- Improving local predictions for shared fusions and documenting.

7.1.0 (2022-03-10)
~~~~~~~~~~~~~~~~~~

- Adding the ability to predict locally from shared composed resources, like
  Ensembles and Fusions.

7.0.1 (2022-03-04)
~~~~~~~~~~~~~~~~~~

- Fixing local Supervised Model to accept stored models as input.
- Improving tests to minimize resource creation.
- Updating dependencies versions.

7.0.0 (2021-08-03)
~~~~~~~~~~~~~~~~~~

- Adding composite sources to the API REST interface methods.
- Adding predictions for images.

6.3.2 (2021-12-02)
------------------

- Fixing local deepnet prediction method to fit new deepnet structure.

6.3.1 (2021-11-03)
------------------

- Improving local ensembles to handle faulty models with no root.

6.3.0 (2021-10-21)
------------------

- Adding activators to local deepnets prediction functions.

6.2.2 (2021-10-11)
------------------

- Fixing underlying dependency used in datetime fields.

6.2.1 (2021-08-10)
------------------

- Fixing predictions for local models with text fields.

6.2.0 (2021-07-22)
------------------

- Minimizing local model information when text or items fields are used.

6.1.2 (2021-06-16)
------------------

- Changing tests mechanism to github actions.

6.1.1 (2021-06-11)
~~~~~~~~~~~~~~~~~~

- Fixing api `get` method. The query string argument was lost.
- Improving api `get`, `create` and `update` methods to avoid unneeded
  iterations.
- Improving docs.

6.1.0 (2021-03-06)
~~~~~~~~~~~~~~~~~~

- Fixing local anomalies when normalize_repeats has been used.

6.0.3 (2021-02-06)
~~~~~~~~~~~~~~~~~~

- Improving local models with default numeric values to automatically fill in
  missings in input data.
- Raising exceptions if trying to update a failed resource.

6.0.2 (2020-12-21)
~~~~~~~~~~~~~~~~~~

- Fixing bug in local anomaly filter.

6.0.1 (2020-11-11)
~~~~~~~~~~~~~~~~~~

- Changing local anomaly filter.
- Fixing update and download methods to wait for the resource to be finished.

6.0.0 (2020-09-02)
~~~~~~~~~~~~~~~~~~

- New compact format for local models.
- Adding cache managing capacities for all local predictors.

5.2.0 (2020-08-19)
~~~~~~~~~~~~~~~~~~

- Adding syntactic sugar methods to the BigML class to help managing resources.

5.1.1 (2020-08-11)
~~~~~~~~~~~~~~~~~~

- Fixing module directory inclusion and improving docs on local anomalies.

5.1.0 (2020-08-07)
~~~~~~~~~~~~~~~~~~

- Refactoring local anomaly to reduce memory requirements.


5.0.1 (2020-08-05)
~~~~~~~~~~~~~~~~~~

- Fixing bug in get_tasks_status to get information about transient net
  errors.

5.0.0 (2020-07-31)
~~~~~~~~~~~~~~~~~~

- Deprecating support for Python 2.7.X versions. Only Python 3 supported
  from this version on.

4.32.3 (2020-07-15)
~~~~~~~~~~~~~~~~~~~

- Extending the Fields class to check the attributes that can be updated in
  a source or dataset fields structure to avoid failing fields updates.

4.32.2 (2020-06-15)
~~~~~~~~~~~~~~~~~~~

- Fixing local anomaly scores for new anomaly detectors with feedback and
  setting the maximum input data precision to five digits.

4.32.1 (2020-06-10)
~~~~~~~~~~~~~~~~~~~

- Fixing local anomaly scores prediction for corner cases of samples with
  one row.

4.32.0 (2020-05-19)
~~~~~~~~~~~~~~~~~~~

- Allowing scripts to be created from gists using the create_script method.
- Improving training examples generation in Fields class.

4.31.2 (2020-05-14)
~~~~~~~~~~~~~~~~~~~

- Fixing problems creating ephemeral prediction resources.

4.31.1 (2020-05-06)
~~~~~~~~~~~~~~~~~~~

- Improving the api.ok method to add an estimated wait time.
- Improving docs and adding TOC for new structure.

4.31.0 (2020-04-22)
~~~~~~~~~~~~~~~~~~~

- Adding REST methods to manage external data connections.

4.30.2 (2020-04-20)
~~~~~~~~~~~~~~~~~~~

- Fixing local anomaly scores for datasets with significant amounts of missings.
- Fixing input data modification for local predictions when fields are not
  used in the models.

4.30.1 (2020-04-16)
~~~~~~~~~~~~~~~~~~~

- Fixing tasks status info for organizations.

4.30.0 (2020-04-10)
~~~~~~~~~~~~~~~~~~~

- Allowing the BigML class to retrieve any resource from local storage and
  extract its fields.

4.29.2 (2020-03-20)
~~~~~~~~~~~~~~~~~~~

- Improving exception handling when retrieving resources.

4.29.1 (2020-03-03)
~~~~~~~~~~~~~~~~~~~

- Fixing bug when disabling SSL verification in predictions only.

4.29.0 (2020-02-29)
~~~~~~~~~~~~~~~~~~~

- Improving api.ok method to allow retries to avoid transient HTTP failures.
- Deprecating the `retries` argument in api.ok.
- Fixing local predictions confidence for weighted models.

4.28.1 (2020-02-04)
~~~~~~~~~~~~~~~~~~~

- Changing api.ok method to avoid raising exceptions when retrieving a
  faulty resource.
- Adding call stack info to local Execution class.
- Fixing docs builder.

4.28.0 (2020-01-23)
~~~~~~~~~~~~~~~~~~~

- Adding Execution local utility to extract the outputs and results from an
  execution.

4.27.3 (2020-01-15)
~~~~~~~~~~~~~~~~~~~

- Fixing local Fusion class to allow using linear regressions.

4.27.2 (2020-01-03)
~~~~~~~~~~~~~~~~~~~

- Fixing warning message and template files in generated code for hadoop
  actionable models.
- Fixing local ensembles that asked for credentials before needing them.

4.27.1 (2019-12-19)
~~~~~~~~~~~~~~~~~~~

- Avoiding asking for credential in classes that predict locally when the
  complete information is provided so no connection is needed.

4.27.0 (2019-12-03)
~~~~~~~~~~~~~~~~~~~

- Extending the custom formats for datetimes allowed as input for local
  predictions.
- Fixing datetimes allowed as input for local predictions. They can be
  provided by name or ID.

4.26.0 (2019-11-27)
~~~~~~~~~~~~~~~~~~~

- Extending the ability to use an alternative url to all predictions,
  centroids, anomaly scores, etc. Also to their batch versions.

4.25.3 (2019-11-26)
~~~~~~~~~~~~~~~~~~~

- Changing bigml-chronos dependency version according to its new internal
  structure. The previous version caused problems when used in some external
  projects.

4.25.2 (2019-11-06)
~~~~~~~~~~~~~~~~~~~

- Fixing bug in local Cluster object when using text or item fields.

4.25.1 (2019-08-28)
~~~~~~~~~~~~~~~~~~~

- Fixing bug in local Fusion object when retrienving from storage.

4.25.0 (2019-08-18)
~~~~~~~~~~~~~~~~~~~

- Adding the ability to parse datetime fields locally for local predictions
  (uses bigml-chronos as a dependency).

4.24.3 (2019-08-08)
~~~~~~~~~~~~~~~~~~~

- Fixing local LinearRegression to work even if `numpy` and `scipy` are
  not installed.

4.24.2 (2019-07-30)
~~~~~~~~~~~~~~~~~~~

- Fixing local EnsemblePredictor code to avoid crash when using deep trees.

4.24.1 (2019-07-05)
~~~~~~~~~~~~~~~~~~~

- Adding missing tokens handling to local models.

4.24.0 (2019-06-28)
~~~~~~~~~~~~~~~~~~~

- Refactoring for multipackage compatibility.
- Deprecating ``ensemble_id`` attribute in local ensembles.
- Extending the BigML class to export model's alternative output formats.

4.23.1 (2019-06-06)
~~~~~~~~~~~~~~~~~~~

- Fixing local predictions for models with unpreferred and datetime fields.

4.23.0 (2019-05-24)
~~~~~~~~~~~~~~~~~~~

- Adding access to tasks information in the API connection object.

4.22.1 (2019-05-23)
~~~~~~~~~~~~~~~~~~~

- Improving the local Ensemble and Fusion classes to use the component
  models when a local JSON file is used as argument.

4.22.0 (2019-05-11)
~~~~~~~~~~~~~~~~~~~

- Fixing bug in local linear regressions for non-invertible confidence bounds
  matrices.
- Adding the option of cloning model resources from shared clonable ones.
- Fixing Fields object for timeseries.

4.21.2 (2019-04-09)
~~~~~~~~~~~~~~~~~~~

- Fixing bug in local fusion regression predictions.

4.21.1 (2019-04-06)
~~~~~~~~~~~~~~~~~~~

- Fixing bug in local linear regression predictions.

4.21.0 (2019-03-22)
~~~~~~~~~~~~~~~~~~~

- Adding REST and local methods for linear regression.


4.20.2 (2019-02-02)
~~~~~~~~~~~~~~~~~~~

- Adding new format for the list of datasets to create a multidataset from.

4.20.1 (2019-02-01)
~~~~~~~~~~~~~~~~~~~

- Fixing bug in local ensemble when used with externally defined connection,
  as found by @KamalGalrani.

4.20.0 (2018-12-01)
~~~~~~~~~~~~~~~~~~~

- Adding PCA REST call methods.
- Adding local PCAs and Projections.

4.19.10 (2018-12-01)
~~~~~~~~~~~~~~~~~~~~

- Fixing local Deepnet predictions for regressions without numpy.

4.19.9 (2018-10-24)
~~~~~~~~~~~~~~~~~~~

- Fixing bug in create datasets for a list of one dataset only.

4.19.8 (2018-09-18)
~~~~~~~~~~~~~~~~~~~

- Fixing bug in create evaluation for timeseries.

4.19.7 (2018-09-13)
~~~~~~~~~~~~~~~~~~~

- Fixing bug when exporting fusions with weights.
- Local fusions now caching all models in the constructor.

4.19.6 (2018-09-12)
~~~~~~~~~~~~~~~~~~~

- Fixing bug when exporting fusions.

4.19.5 (2018-08-23)
~~~~~~~~~~~~~~~~~~~

- Changing source upload `async` parameter to ensure Python 3.7 compatibility.

4.19.4 (2018-07-18)
~~~~~~~~~~~~~~~~~~~

- Fixing local logistic regression predictions with weight field missing in
  input data.

4.19.3 (2018-06-26)
~~~~~~~~~~~~~~~~~~~

- Modifying local fusion object to adapt to logistic regressions with
  no missing numerics allowed.

4.19.2 (2018-06-25)
~~~~~~~~~~~~~~~~~~~

- Removing left over comment.

4.19.1 (2018-06-23)
~~~~~~~~~~~~~~~~~~~

- Refactoring the local classes that manage models information to create
  predictions. Now all of them allow a path, an ID or a dictionary to be
  the first argument in the constructor.

4.19.0 (2018-06-20)
~~~~~~~~~~~~~~~~~~~

- Adding local fusion object and predict methods.
- Fixing error handling in local objects.
- Fixing bug in local logistic regressions when using a local stored file.

4.18.3 (2018-06-03)
~~~~~~~~~~~~~~~~~~~

- Adding batch predictions for fusion resources.

4.18.2 (2018-05-28)
~~~~~~~~~~~~~~~~~~~

- Adding predictions and evaluations for fusion resources.

4.18.1 (2018-05-19)
~~~~~~~~~~~~~~~~~~~

- Fixing bug when unused field IDs are used in local prediction inputs.

4.18.0 (2018-05-19)
~~~~~~~~~~~~~~~~~~~

- Adding methods for the REST calls to OptiMLs and Fusions.

4.17.1 (2018-05-15)
~~~~~~~~~~~~~~~~~~~

- Adding the option to export PMML models when available.
- Fixing bug in local deepnets for regressions.
- Adapting local Cluster and Anomaly detector to not include summary fields
  information.

4.17.0 (2018-05-02)
~~~~~~~~~~~~~~~~~~~

- Adding the local Supervised Model class to allow local predictions with
  any supervised model resource.

4.16.2 (2018-04-31)
~~~~~~~~~~~~~~~~~~~

- Adding the `export` and `export_last` methods to download and save the
  remote resources in the local file system.

4.16.1 (2018-04-24)
~~~~~~~~~~~~~~~~~~~

- Fixing bug in local deepnet predictions.

4.16.0 (2018-04-03)
~~~~~~~~~~~~~~~~~~~

- Deprecating local predictions formatting arguments. Formatting is available
  through the `cast_prediction` function.

4.15.2 (2018-02-24)
~~~~~~~~~~~~~~~~~~~

- Local predictions for regression ensembles corrected for strange models
  whose nodes lack the confidence attribute.

4.15.1 (2018-02-07)
~~~~~~~~~~~~~~~~~~~

- Removing logs left in local ensemble object.

4.15.0 (2018-02-07)
~~~~~~~~~~~~~~~~~~~

- Adding organizations support for all the API calls.

4.14.0 (2018-01-22)
~~~~~~~~~~~~~~~~~~~

- Deprecating `dev_mode` flag from BigML's API connection. The development
  environment has been deprecated.
- Fixing bug in local cluster output to CSV.
- Improving docs with local batch predictions examples.
- Adding operating kind support for local predictions in models and ensembles.
- Fixing bug in ensembles local predictions with probability.
- Fixing bug in logistic regression local predictions with operating points.

4.13.7 (2018-01-02)
~~~~~~~~~~~~~~~~~~~

- Changing local predictions with threshold to meet changes in backend.
- Adding support for configurations REST API calls.

4.13.6 (2017-12-05)
~~~~~~~~~~~~~~~~~~~

- Fixing predict confidence method in local ensembles.

4.13.5 (2017-11-23)
~~~~~~~~~~~~~~~~~~~

- Adding operating point local predictions to deepnets.

4.13.4 (2017-11-21)
~~~~~~~~~~~~~~~~~~~

- Fixing bug in local ensemble predictions with operating points.
- Fixing bug for local EnsemblePredictor class.

4.13.3 (2017-11-14)
~~~~~~~~~~~~~~~~~~~

- Fixing bug in local ensemble predictions for inputs that don't match the
  expected field types.

4.13.2 (2017-11-14)
~~~~~~~~~~~~~~~~~~~

- Adding left out static files for local ensemble predictor functions.

4.13.1 (2017-11-10)
~~~~~~~~~~~~~~~~~~~

- Refactoring local BoostedTrees and adding the EnsemblePredictor to
  use the local predict functions of each model to generate the ensemble
  prediction.

4.13.0 (2017-11-07)
~~~~~~~~~~~~~~~~~~~

- Adding operating point thresholds to local model, ensemble and logistic
  regression predictions.

4.12.1 (2017-10-12)
~~~~~~~~~~~~~~~~~~~

- Fixing bug in the local Deepnet predictions when numpy is not installed.

4.12.0 (2017-10-04)
~~~~~~~~~~~~~~~~~~~

- Adding support for Deepnets REST API calls and local predictions using
  the local Deepnet object.

4.11.3 (2017-09-29)
~~~~~~~~~~~~~~~~~~~

- Fixing bug in the local Ensemble object. Failed to use the
  stored ensemble object.

4.11.2 (2017-07-29)
~~~~~~~~~~~~~~~~~~~

- Fixing bug in source uploads using Python3 when reading data from stdin.

4.11.1 (2017-06-23)
~~~~~~~~~~~~~~~~~~~

- Fixing bug in source uploads using Python3 when a category is set.

4.11.0 (2017-06-23)
~~~~~~~~~~~~~~~~~~~

- Adding REST methods for managing time-series and local time-series object
  to create forecasts.

4.10.5 (2017-07-13)
~~~~~~~~~~~~~~~~~~~

- Fixing bug in the sources upload using Python3. Server changes need the
  content-type of the file to be sent.

4.10.4 (2017-06-21)
~~~~~~~~~~~~~~~~~~~

- Fixing bug in the local model predicted distributions for weighted models.
- Fixing bug in predicted probability for local model predictions
  using weighted models.

4.10.3 (2017-06-07)
~~~~~~~~~~~~~~~~~~~

- Changing boosted local ensembles predictions to match the improvements in
  API.
- Fixing bug in association rules export to CSV and lisp for rules with numeric
  attributes.

4.10.2 (2017-05-23)
~~~~~~~~~~~~~~~~~~~

- Fixing bug: local Model object failed when retrieving old JSON models from
  local storage.

4.10.1 (2017-05-15)
~~~~~~~~~~~~~~~~~~~

- Internal refactoring preparing for extensions in BigMLer.

4.10.0 (2017-05-05)
~~~~~~~~~~~~~~~~~~~

- Adding predic_probability and predict_confidence methods to local model and
  ensemble.
- Internal refactoring of local model classes preparing for extensions
  in BigMLer.

4.9.2 (2017-03-26)
~~~~~~~~~~~~~~~~~~

- Fixing bug: local model slugifying fails when fields have empty names.

4.9.1 (2017-03-23)
~~~~~~~~~~~~~~~~~~

- Adding methods to local cluster: closest data points from a
  reference point and centroids ordered from a reference point.
- Modifying internal codes in MultiVote class.

4.9.0 (2017-03-21)
~~~~~~~~~~~~~~~~~~

- Adding boosted ensembles to the local Ensemble object.

4.8.3 (2017-03-01)
~~~~~~~~~~~~~~~~~~

- Fixing bug in local logistic regression predictions when a constant field is
  forced as input field.

4.8.2 (2017-02-09)
~~~~~~~~~~~~~~~~~~

- Fixing bug: Adapting to changes in Python 3.6 which cause the connection to
  the API using SSL to fail.

4.8.1 (2017-01-11)
~~~~~~~~~~~~~~~~~~

- Changing local association parameters to adapt to API docs specifications.

4.8.0 (2017-01-08)
~~~~~~~~~~~~~~~~~~

- Adapting to final format of local association sets and adding tests.

4.7.3 (2016-12-03)
~~~~~~~~~~~~~~~~~~