Exemple #1
0
 def setUp(self):
     self.tmp_dir = tempfile.TemporaryDirectory()
     self.first_model = Model("first_model")
     self.second_model = Model("second_model")
     path = pathlib.Path(self.tmp_dir.name).joinpath("first_model.mdl")
     with open(path, 'wb') as output:
         dill.dump(self.first_model, output, dill.HIGHEST_PROTOCOL)
     self.mb = ModelBase(name="my mb", model_dir=self.tmp_dir.name)
Exemple #2
0
 def test_dump_models_dump_multiple(self):
     model = Model()
     expected_dill_models = [
         dill.dumps(model, dill.HIGHEST_PROTOCOL),
         dill.dumps(model, dill.HIGHEST_PROTOCOL)
     ]
     result_dumped_models, _ = Client.Client.dump_models([model, model])
     self.assertEqual(expected_dill_models, result_dumped_models)
Exemple #3
0
 def test_send_models_single_working(self):
     model = Model()
     with mock.patch("socketio.Client"):
         client = Client.Client("localhost", 1234)
         client.send_models(model)
         client.socket.emit.assert_called_once_with(
             "models",
             client.dump_models([model])[0],
             callback=client._callback_function)
Exemple #4
0
    def test_add(self):
        self.mb.add(self.second_model)
        with self.subTest("added model"):
            self.assertTrue(len(self.mb.models) == 2)

        second_model = Model("second_model")
        self.mb.add(second_model)
        with self.subTest("override existing model"):
            self.assertTrue(len(self.mb.models) == 2)
        with self.subTest("added model under new name"):
            self.assertNotEqual(self.mb.models["second_model"],
                                self.second_model)

        self.mb.add(second_model, name="first_model")
        with self.subTest("added same model under new name"):
            self.assertEqual(self.mb.models["first_model"],
                             self.mb.models["second_model"])
Exemple #5
0
    def test_load_all(self):
        new_model = Model()
        path = pathlib.Path(self.tmp_dir.name).joinpath("first_model.mdl")
        with open(path, 'wb') as output:
            dill.dump(new_model, output, dill.HIGHEST_PROTOCOL)

        with self.subTest("Load all"):
            mb = ModelBase(name="my mb",
                           model_dir=self.tmp_dir.name,
                           watchdog=False,
                           load_all=True)
            self.assertTrue(len(mb.models) == 1)
        with self.subTest("Load nothing"):
            mb = ModelBase(name="my mb",
                           model_dir=self.tmp_dir.name,
                           watchdog=False,
                           load_all=False)
            self.assertTrue(len(mb.models) == 0)
Exemple #6
0
 def test_dump_models_multiple(self):
     model = Model()
     expected_model_list = [model.name, model.name]
     _, result_model_list = Client.Client.dump_models([model, model])
     self.assertEqual(expected_model_list, result_model_list)
Exemple #7
0
# Copyright (c) 2019 Philipp Lucas ([email protected])
"""
@author: Philipp Lucas

Some test queries that should not raise an execption.
"""
import pandas as pd

from mb.modelbase import Density, Probability, Split, Aggregation, Model
from mb.modelbase import MixableCondGaussianModel as CondGaussian

from mb.data import crabs

if __name__ == '__main__':

    model = Model.load('crabs_test.mdl')
    # model.parallel_processing = False

    data = crabs.mixed()
    # model = CondGaussian("TestMod").fit(df=data)
    # Model.save(model, 'crabs_test.mdl')

    print(str(model.names))
    # prints: ['species', 'sex', 'FL', 'RW', 'CL', 'CW', 'BD']

    sex = model.byname('sex')
    species = model.byname('species')
    FL = model.byname('FL')
    RW = model.byname('RW')

    res = model.predict(['RW', Density([RW])],