eyadgaran / SimpleML / 298

pending completion

Build # 298

Build Type

Pull #27

travis-ci

Committed by

web-flow

Commit Message

<a href="https://github.com/eyadgaran/SimpleML/commit/<a class=hub.com/eyadgaran/SimpleML/commit/<a class="double-link" href="https://git"><a class=hub.com/eyadgaran/SimpleML/commit/<a class="double-link" href="https://git"><a class=hub.com/eyadgaran/SimpleML/commit/<a class="double-link" href="https://git"><a class=hub.com/eyadgaran/SimpleML/commit/<a class="double-link" href="https://git"><a class=hub.com/eyadgaran/SimpleML/commit/71c00553d3c5879b25365f87f9bb36eb91bb5118">71c00553d">&lt;a href=&quot;https://github.com/eyadgaran/SimpleML/commit/</a><a class="double-link" href="https://github.com/eyadgaran/SimpleML/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/eyadgaran/SimpleML/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/eyadgaran/SimpleML/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/eyadgaran/SimpleML/commit/71c00553d3c5879b25365f87f9bb36eb91bb5118">71c00553d</a><a href="https://github.com/eyadgaran/SimpleML/commit/71c00553d3c5879b25365f87f9bb36eb91bb5118">&lt;a href=&quot;https://github.com/eyadgaran/SimpleML/commit/71c00553d3c5879b25365f87f9bb36eb91bb5118&quot;&gt;&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/eyadgaran/SimpleML/commit/&amp;lt;/a&amp;gt;&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://github.com/eyadgaran/SimpleML/commit/&amp;amp;lt;a class=&amp;amp;quot;double-link&amp;amp;quot; href=&amp;amp;quot;https://git&amp;quot;&amp;gt;&amp;amp;lt;a class=&amp;lt;/a&amp;gt;hub.com/eyadgaran/SimpleML/commit/71c00553d3c5879b25365f87f9bb36eb91bb5118&amp;quot;&amp;gt;71c00553d&amp;lt;/a&amp;gt;&amp;lt;a href=&amp;quot;https://github.com/eyadgaran/SimpleML/commit/71c00553d3c5879b25365f87f9bb36eb91bb5118&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/eyadgaran/SimpleML/commit/71c00553d3c5879b25365f87f9bb36eb&amp;lt;/a&amp;gt;91bb51</a>18&quot;&gt;&amp;quot;&amp;gt;Merge &amp;lt;/a&amp;gt;&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://github.com/eyadgaran/SimpleML/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://github.com/eyadgaran/SimpleML/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/eyadgaran/SimpleML/commit/e72a8321c&... (continued)

Pull Request Pull Request #27: Develop

Run Details

840 of 840 new or added lines in 22 files covered. (100.0%)

2244 of 4282 relevant lines covered (52.41%)

3.14 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

24.85

/simpleml/utils/training/create_persistable.py

'''
Module with helper classes to create new persistables
'''
from abc import ABCMeta, abstractmethod
from simpleml.registries import SIMPLEML_REGISTRY
from simpleml.datasets.base_dataset import Dataset
from simpleml.pipelines.base_pipeline import Pipeline
from simpleml.models.base_model import Model
from simpleml.metrics.base_metric import Metric
from simpleml.utils.errors import TrainingError
import logging
from future.utils import with_metaclass

LOGGER = logging.getLogger(__name__)

__author__ = 'Elisha Yadgaran'


class PersistableCreator(with_metaclass(ABCMeta, object)):

    @classmethod
    def retrieve_or_create(self, **kwargs):
        '''
        Wrapper method to first attempt to retrieve a matching persistable and
        then create a new one if it isn't found
        '''
        cls, filters = self.determine_filters(**kwargs)
        persistable = self.retrieve(cls, filters)

        if persistable is not None:
            LOGGER.info('Using existing persistable: {}, {}, {}'.format(cls.__tablename__, persistable.name, persistable.version))
            persistable.load()
            return persistable

        else:
            LOGGER.info('Existing {} not found. Creating new one now'.format(cls.__tablename__))
            persistable = self.create(**kwargs)
            LOGGER.info('Using new persistable: {}, {}, {}'.format(cls.__tablename__, persistable.name, persistable.version))
            return persistable

    @staticmethod
    def retrieve(cls, filters):
        '''
        Query database using the table model (cls) and filters for a matching
        persistable
        '''
        return cls.where(**filters).order_by(cls.version.desc()).first()

    @staticmethod
    def retrieve_dependency(dependency_cls, **dependency_kwargs):
        '''
        Base method to query for dependency
        Raises TrainingError if dependency does not exist
        '''
        if not dependency_kwargs:
            raise TrainingError('Must pass at least one key:value to look up in database')
        dependency = dependency_cls.retrieve(
            *dependency_cls.determine_filters(**dependency_kwargs))
        if dependency is None:
            raise TrainingError('Expected dependency is missing')
        dependency.load()
        return dependency

    @classmethod
    def retrieve_dataset(cls,
                         dataset=None,
                         dataset_id: str = None,
                         dataset_kwargs=None,
                         **kwargs):
        if dataset is not None:
            return dataset
        if dataset_id is not None:
            return cls.retrieve_dependency(DatasetCreator, id=dataset_id)
        if dataset_kwargs is not None:
            # Use dependency reference to retrieve object
            return cls.retrieve_dependency(DatasetCreator, **dataset_kwargs)

    @classmethod
    def retrieve_pipeline(cls,
                          pipeline=None,
                          pipeline_id: str = None,
                          pipeline_kwargs=None,
                          **kwargs):
        if pipeline is not None:
            return pipeline
        if pipeline_id is not None:
            return cls.retrieve_dependency(PipelineCreator, id=pipeline_id)
        if pipeline_kwargs is not None:
            # Use dependency reference to retrieve object
            return cls.retrieve_dependency(PipelineCreator, **pipeline_kwargs)

    @classmethod
    def retrieve_model(cls,
                       model=None,
                       model_id: str = None,
                       model_kwargs=None,
                       **kwargs):
        if model is not None:
            return model
        if model_id is not None:
            return cls.retrieve_dependency(ModelCreator, id=model_id)
        if model_kwargs is not None:
            # Use dependency reference to retrieve object
            return cls.retrieve_dependency(ModelCreator, **model_kwargs)

    @abstractmethod
    def determine_filters(cls, strict=False, **kwargs):
        '''
        method to determine which filters to apply when looking for
        existing persistable

        :param strict: whether to fit objects first before assuming they are identical
        In theory if all inputs and classes are the same, the outputs should deterministically
        be the same as well (up to random iter). So, you dont need to fit objects
        to be sure they are the same

        Default design iterates through 2 (or 3) options when retrieving persistables:
            1) By name and version (unique properties that define persistables)
            2) By name, registered_name, and computed hash
            2.5) Optionally, just use name and registered_name (assumes class
                definition is the same and would result in an identical persistable)

        Returns: database class, filter dictionary
        '''

    @abstractmethod
    def create(cls, **kwargs):
        '''
        method to create a new persistable with the desired parameters
        kwargs are passed directly to persistable
        '''

    @staticmethod
    def retrieve_from_registry(registered_name):
        '''
        stateless method to query registry for class definitions. handles errors
        '''
        cls = SIMPLEML_REGISTRY.get(registered_name)
        if cls is None:
            raise TrainingError('Referenced class unregistered: {}'.format(registered_name))
        return cls


class DatasetCreator(PersistableCreator):
    @classmethod
    def determine_filters(cls, strict=True, **kwargs):
        '''
        stateless method to determine which filters to apply when looking for
        existing persistable

        Returns: database class, filter dictionary

        :param registered_name: Class name registered in SimpleML
        :param strict: whether to assume same class and name = same persistable,
        or, load the data and compare the hash
        '''
        if ('id' not in kwargs) and ('name' not in kwargs or 'version' not in kwargs) \
                and ('registered_name' not in kwargs):
            raise TrainingError('Need to pass at least one of: `id`, `name, version`, `registered_name` to compare against existing persistables')

        if 'id' in kwargs:
            filters = {
                'id': kwargs['id']
            }

        elif 'name' in kwargs and 'version' in kwargs:
            filters = {
                'name': kwargs['name'],
                'version': kwargs['version'],
            }

        else:
            registered_name = kwargs['registered_name']
            # Check if dependency object was passed
            pipeline = cls.retrieve_pipeline(**kwargs)

            if strict:
                # Build dummy object to retrieve hash to look for
                new_dataset = cls.retrieve_from_registry(registered_name)(**kwargs)
                new_dataset.add_pipeline(pipeline)
                new_dataset.build_dataframe()

                filters = {
                    'name': new_dataset.name,
                    'registered_name': new_dataset.registered_name,
                    'hash_': new_dataset._hash()
                }

            else:
                # Assume combo of name, class, and pipeline will be unique
                filters = {
                    'registered_name': registered_name,
                    'pipeline_id': pipeline.id if pipeline is not None else None
                }
                if 'name' in kwargs:
                    filters['name'] = kwargs['name']

        return Dataset, filters

    @classmethod
    def create(cls, registered_name, pipeline=None, **kwargs):
        '''
        Stateless method to create a new persistable with the desired parameters
        kwargs are passed directly to persistable

        :param registered_name: Class name registered in SimpleML
        :param dataset_pipeline: dataset pipeline object
        '''
        pipeline = cls.retrieve_pipeline(**kwargs)
        new_dataset = cls.retrieve_from_registry(registered_name)(**kwargs)
        new_dataset.add_pipeline(pipeline)
        new_dataset.build_dataframe()
        new_dataset.save()

        return new_dataset


class PipelineCreator(PersistableCreator):
    @classmethod
    def determine_filters(cls, strict=False, **kwargs):
        '''
        stateless method to determine which filters to apply when looking for
        existing persistable

        Returns: database class, filter dictionary

        :param registered_name: Class name registered in SimpleML
        :param strict: whether to fit objects first before assuming they are identical
        In theory if all inputs and classes are the same, the outputs should deterministically
        be the same as well (up to random iter). So, you dont need to fit objects
        to be sure they are the same
        '''
        if ('id' not in kwargs) and ('name' not in kwargs or 'version' not in kwargs) \
                and ('registered_name' not in kwargs or ('dataset' not in kwargs and 'dataset_kwargs' not in kwargs)):
            raise TrainingError('Need to pass at least one of: `id`, `name, version`, `registered_name, dataset`, `registered_name, dataset_kwargs` to compare against existing persistables')

        if 'id' in kwargs:
            filters = {
                'id': kwargs['id']
            }

        elif 'name' in kwargs and 'version' in kwargs:
            filters = {
                'name': kwargs['name'],
                'version': kwargs['version'],
            }

        else:
            dataset = cls.retrieve_dataset(**kwargs)
            # Build dummy object to retrieve hash to look for
            registered_name = kwargs['registered_name']
            new_pipeline = cls.retrieve_from_registry(registered_name)(**kwargs)
            new_pipeline.add_dataset(dataset)
            if strict:
                new_pipeline.fit()

            filters = {
                'name': new_pipeline.name,
                'registered_name': new_pipeline.registered_name,
                'hash_': new_pipeline._hash()
            }

        return Pipeline, filters

    @classmethod
    def create(cls, registered_name, **kwargs):
        '''
        Stateless method to create a new persistable with the desired parameters
        kwargs are passed directly to persistable

        :param registered_name: Class name registered in SimpleML
        :param dataset: dataset object
        '''
        dataset = cls.retrieve_dataset(**kwargs)
        new_pipeline = cls.retrieve_from_registry(registered_name)(**kwargs)
        new_pipeline.add_dataset(dataset)
        new_pipeline.fit()
        new_pipeline.save()

        return new_pipeline


class ModelCreator(PersistableCreator):
    @classmethod
    def determine_filters(cls, strict=False, **kwargs):
        '''
        stateless method to determine which filters to apply when looking for
        existing persistable

        Returns: database class, filter dictionary

        :param registered_name: Class name registered in SimpleML
        :param strict: whether to fit objects first before assuming they are identical
        In theory if all inputs and classes are the same, the outputs should deterministically
        be the same as well (up to random iter). So, you dont need to fit objects
        to be sure they are the same
        '''
        if ('id' not in kwargs) and ('name' not in kwargs or 'version' not in kwargs) \
                and ('registered_name' not in kwargs or ('pipeline' not in kwargs and 'pipeline_kwargs' not in kwargs)):
            raise TrainingError('Need to pass at least one of: `id`, `name, version`, `registered_name, pipeline`, `registered_name, pipeline_kwargs` to compare against existing persistables')

        if 'id' in kwargs:
            filters = {
                'id': kwargs['id']
            }

        elif 'name' in kwargs and 'version' in kwargs:
            filters = {
                'name': kwargs['name'],
                'version': kwargs['version'],
            }

        else:
            pipeline = cls.retrieve_pipeline(**kwargs)
            # Build dummy object to retrieve hash to look for
            registered_name = kwargs['registered_name']
            new_model = cls.retrieve_from_registry(registered_name)(**kwargs)
            new_model.add_pipeline(pipeline)
            if strict:
                new_model.fit()

            filters = {
                'name': new_model.name,
                'registered_name': new_model.registered_name,
                'hash_': new_model._hash()
            }

        return Model, filters

    @classmethod
    def create(cls, registered_name, **kwargs):
        '''
        Stateless method to create a new persistable with the desired parameters
        kwargs are passed directly to persistable

        :param registered_name: Class name registered in SimpleML
        :param pipeline: pipeline object
        '''
        pipeline = cls.retrieve_pipeline(**kwargs)
        new_model = cls.retrieve_from_registry(registered_name)(**kwargs)
        new_model.add_pipeline(pipeline)
        new_model.fit()
        new_model.save()

        return new_model


class MetricCreator(PersistableCreator):
    @classmethod
    def determine_filters(cls, strict=False, **kwargs):
        '''
        stateless method to determine which filters to apply when looking for
        existing persistable

        Returns: database class, filter dictionary

        :param registered_name: Class name registered in SimpleML
        :param strict: whether to fit objects first before assuming they are identical
        In theory if all inputs and classes are the same, the outputs should deterministically
        be the same as well (up to random iter). So, you dont need to fit objects
        to be sure they are the same
        '''
        if ('id' not in kwargs) and \
            ('name' not in kwargs or 'version' not in kwargs or ('model_id' not in kwargs and 'model' not in kwargs)) \
                and ('registered_name' not in kwargs):
            raise TrainingError('Need to pass at least one of: `id`, `name, version, model`, `name, version, model_id`, `registered_name` to compare against existing persistables')

        model = cls.retrieve_model(**kwargs)
        dataset = cls.retrieve_dataset(**kwargs)

        if 'id' in kwargs:
            filters = {
                'id': kwargs['id']
            }

        elif 'name' in kwargs and 'version' in kwargs and model is not None:
            filters = {
                'name': kwargs['name'],
                'version': kwargs['version'],
                'model_id': model.id,
            }

        else:
            # Build dummy object to retrieve hash to look for
            registered_name = kwargs['registered_name']
            new_metric = cls.retrieve_from_registry(registered_name)(**kwargs)
            new_metric.add_model(model)
            new_metric.add_dataset(dataset)
            if strict:
                new_metric.score()

            filters = {
                'name': new_metric.name,
                'registered_name': registered_name,
                'hash_': new_metric._hash()
            }

        return Metric, filters

    @classmethod
    def create(cls, registered_name, **kwargs):
        '''
        Stateless method to create a new persistable with the desired parameters
        kwargs are passed directly to persistable

        :param registered_name: Class name registered in SimpleML
        :param model: model class
        '''
        model = cls.retrieve_model(**kwargs)
        dataset = cls.retrieve_dataset(**kwargs)
        new_metric = cls.retrieve_from_registry(registered_name)(**kwargs)
        new_metric.add_model(model)
        new_metric.add_dataset(dataset)
        new_metric.score()
        new_metric.save()

        return new_metric

1	'''
2	Module with helper classes to create new persistables
3	'''
4	from abc import ABCMeta, abstractmethod	6✔
5	from simpleml.registries import SIMPLEML_REGISTRY	6✔
6	from simpleml.datasets.base_dataset import Dataset	6✔
7	from simpleml.pipelines.base_pipeline import Pipeline	6✔
8	from simpleml.models.base_model import Model	6✔
9	from simpleml.metrics.base_metric import Metric	6✔
10	from simpleml.utils.errors import TrainingError	6✔
11	import logging	6✔
12	from future.utils import with_metaclass	6✔
13
14	LOGGER = logging.getLogger(__name__)	6✔
15
16	__author__ = 'Elisha Yadgaran'	6✔
17
18
19	class PersistableCreator(with_metaclass(ABCMeta, object)):	6✔
20
21	@classmethod	6✔
22	def retrieve_or_create(self, **kwargs):	2✔
23	'''
24	Wrapper method to first attempt to retrieve a matching persistable and
25	then create a new one if it isn't found
26	'''
27	cls, filters = self.determine_filters(**kwargs)	×
28	persistable = self.retrieve(cls, filters)	×
29
30	if persistable is not None:	×
31	LOGGER.info('Using existing persistable: {}, {}, {}'.format(cls.__tablename__, persistable.name, persistable.version))	×
32	persistable.load()	×
33	return persistable	×
34
35	else:
36	LOGGER.info('Existing {} not found. Creating new one now'.format(cls.__tablename__))	×
37	persistable = self.create(**kwargs)	×
38	LOGGER.info('Using new persistable: {}, {}, {}'.format(cls.__tablename__, persistable.name, persistable.version))	×
39	return persistable	×
40
41	@staticmethod	6✔
42	def retrieve(cls, filters):	2✔
43	'''
44	Query database using the table model (cls) and filters for a matching
45	persistable
46	'''
47	return cls.where(**filters).order_by(cls.version.desc()).first()	×
48
49	@staticmethod	6✔
50	def retrieve_dependency(dependency_cls, **dependency_kwargs):	2✔
51	'''
52	Base method to query for dependency
53	Raises TrainingError if dependency does not exist
54	'''
55	if not dependency_kwargs:	×
56	raise TrainingError('Must pass at least one key:value to look up in database')	×
57	dependency = dependency_cls.retrieve(	×
58	dependency_cls.determine_filters(*dependency_kwargs))
59	if dependency is None:	×
60	raise TrainingError('Expected dependency is missing')	×
61	dependency.load()	×
62	return dependency	×
63
64	@classmethod	6✔
65	def retrieve_dataset(cls,	6✔
66	dataset=None,
67	dataset_id: str = None,
68	dataset_kwargs=None,
69	**kwargs):
70	if dataset is not None:	×
71	return dataset	×
72	if dataset_id is not None:	×
73	return cls.retrieve_dependency(DatasetCreator, id=dataset_id)	×
74	if dataset_kwargs is not None:	×
75	# Use dependency reference to retrieve object
76	return cls.retrieve_dependency(DatasetCreator, **dataset_kwargs)	×
77
78	@classmethod	6✔
79	def retrieve_pipeline(cls,	6✔
80	pipeline=None,
81	pipeline_id: str = None,
82	pipeline_kwargs=None,
83	**kwargs):
84	if pipeline is not None:	×
85	return pipeline	×
86	if pipeline_id is not None:	×
87	return cls.retrieve_dependency(PipelineCreator, id=pipeline_id)	×
88	if pipeline_kwargs is not None:	×
89	# Use dependency reference to retrieve object
90	return cls.retrieve_dependency(PipelineCreator, **pipeline_kwargs)	×
91
92	@classmethod	6✔
93	def retrieve_model(cls,	6✔
94	model=None,
95	model_id: str = None,
96	model_kwargs=None,
97	**kwargs):
98	if model is not None:	×
99	return model	×
100	if model_id is not None:	×
101	return cls.retrieve_dependency(ModelCreator, id=model_id)	×
102	if model_kwargs is not None:	×
103	# Use dependency reference to retrieve object
104	return cls.retrieve_dependency(ModelCreator, **model_kwargs)	×
105
106	@abstractmethod	6✔
107	def determine_filters(cls, strict=False, **kwargs):	6✔
108	'''
109	method to determine which filters to apply when looking for
110	existing persistable
111
112	:param strict: whether to fit objects first before assuming they are identical
113	In theory if all inputs and classes are the same, the outputs should deterministically
114	be the same as well (up to random iter). So, you dont need to fit objects
115	to be sure they are the same
116
117	Default design iterates through 2 (or 3) options when retrieving persistables:
118	1) By name and version (unique properties that define persistables)
119	2) By name, registered_name, and computed hash
120	2.5) Optionally, just use name and registered_name (assumes class
121	definition is the same and would result in an identical persistable)
122
123	Returns: database class, filter dictionary
124	'''
125
126	@abstractmethod	6✔
127	def create(cls, **kwargs):	2✔
128	'''
129	method to create a new persistable with the desired parameters
130	kwargs are passed directly to persistable
131	'''
132
133	@staticmethod	6✔
134	def retrieve_from_registry(registered_name):	2✔
135	'''
136	stateless method to query registry for class definitions. handles errors
137	'''
138	cls = SIMPLEML_REGISTRY.get(registered_name)	×
139	if cls is None:	×
140	raise TrainingError('Referenced class unregistered: {}'.format(registered_name))	×
141	return cls	×
142
143
144	class DatasetCreator(PersistableCreator):	6✔
145	@classmethod	6✔
146	def determine_filters(cls, strict=True, **kwargs):	6✔
147	'''
148	stateless method to determine which filters to apply when looking for
149	existing persistable
150
151	Returns: database class, filter dictionary
152
153	:param registered_name: Class name registered in SimpleML
154	:param strict: whether to assume same class and name = same persistable,
155	or, load the data and compare the hash
156	'''
157	if ('id' not in kwargs) and ('name' not in kwargs or 'version' not in kwargs) \	×
158	and ('registered_name' not in kwargs):
159	raise TrainingError('Need to pass at least one of: `id`, `name, version`, `registered_name` to compare against existing persistables')	×
160
161	if 'id' in kwargs:	×
162	filters = {	×
163	'id': kwargs['id']
164	}
165
166	elif 'name' in kwargs and 'version' in kwargs:	×
167	filters = {	×
168	'name': kwargs['name'],
169	'version': kwargs['version'],
170	}
171
172	else:
173	registered_name = kwargs['registered_name']	×
174	# Check if dependency object was passed
175	pipeline = cls.retrieve_pipeline(**kwargs)	×
176
177	if strict:	×
178	# Build dummy object to retrieve hash to look for
179	new_dataset = cls.retrieve_from_registry(registered_name)(**kwargs)	×
180	new_dataset.add_pipeline(pipeline)	×
181	new_dataset.build_dataframe()	×
182
183	filters = {	×
184	'name': new_dataset.name,
185	'registered_name': new_dataset.registered_name,
186	'hash_': new_dataset._hash()
187	}
188
189	else:
190	# Assume combo of name, class, and pipeline will be unique
191	filters = {	×
192	'registered_name': registered_name,
193	'pipeline_id': pipeline.id if pipeline is not None else None
194	}
195	if 'name' in kwargs:	×
196	filters['name'] = kwargs['name']	×
197
198	return Dataset, filters	×
199
200	@classmethod	6✔
201	def create(cls, registered_name, pipeline=None, **kwargs):	6✔
202	'''
203	Stateless method to create a new persistable with the desired parameters
204	kwargs are passed directly to persistable
205
206	:param registered_name: Class name registered in SimpleML
207	:param dataset_pipeline: dataset pipeline object
208	'''
209	pipeline = cls.retrieve_pipeline(**kwargs)	×
210	new_dataset = cls.retrieve_from_registry(registered_name)(**kwargs)	×
211	new_dataset.add_pipeline(pipeline)	×
212	new_dataset.build_dataframe()	×
213	new_dataset.save()	×
214
215	return new_dataset	×
216
217
218	class PipelineCreator(PersistableCreator):	6✔
219	@classmethod	6✔
220	def determine_filters(cls, strict=False, **kwargs):	6✔
221	'''
222	stateless method to determine which filters to apply when looking for
223	existing persistable
224
225	Returns: database class, filter dictionary
226
227	:param registered_name: Class name registered in SimpleML
228	:param strict: whether to fit objects first before assuming they are identical
229	In theory if all inputs and classes are the same, the outputs should deterministically
230	be the same as well (up to random iter). So, you dont need to fit objects
231	to be sure they are the same
232	'''
233	if ('id' not in kwargs) and ('name' not in kwargs or 'version' not in kwargs) \	×
234	and ('registered_name' not in kwargs or ('dataset' not in kwargs and 'dataset_kwargs' not in kwargs)):
235	raise TrainingError('Need to pass at least one of: `id`, `name, version`, `registered_name, dataset`, `registered_name, dataset_kwargs` to compare against existing persistables')	×
236
237	if 'id' in kwargs:	×
238	filters = {	×
239	'id': kwargs['id']
240	}
241
242	elif 'name' in kwargs and 'version' in kwargs:	×
243	filters = {	×
244	'name': kwargs['name'],
245	'version': kwargs['version'],
246	}
247
248	else:
249	dataset = cls.retrieve_dataset(**kwargs)	×
250	# Build dummy object to retrieve hash to look for
251	registered_name = kwargs['registered_name']	×
252	new_pipeline = cls.retrieve_from_registry(registered_name)(**kwargs)	×
253	new_pipeline.add_dataset(dataset)	×
254	if strict:	×
255	new_pipeline.fit()	×
256
257	filters = {	×
258	'name': new_pipeline.name,
259	'registered_name': new_pipeline.registered_name,
260	'hash_': new_pipeline._hash()
261	}
262
263	return Pipeline, filters	×
264
265	@classmethod	6✔
266	def create(cls, registered_name, **kwargs):	2✔
267	'''
268	Stateless method to create a new persistable with the desired parameters
269	kwargs are passed directly to persistable
270
271	:param registered_name: Class name registered in SimpleML
272	:param dataset: dataset object
273	'''
274	dataset = cls.retrieve_dataset(**kwargs)	×
275	new_pipeline = cls.retrieve_from_registry(registered_name)(**kwargs)	×
276	new_pipeline.add_dataset(dataset)	×
277	new_pipeline.fit()	×
278	new_pipeline.save()	×
279
280	return new_pipeline	×
281
282
283	class ModelCreator(PersistableCreator):	6✔
284	@classmethod	6✔
285	def determine_filters(cls, strict=False, **kwargs):	6✔
286	'''
287	stateless method to determine which filters to apply when looking for
288	existing persistable
289
290	Returns: database class, filter dictionary
291
292	:param registered_name: Class name registered in SimpleML
293	:param strict: whether to fit objects first before assuming they are identical
294	In theory if all inputs and classes are the same, the outputs should deterministically
295	be the same as well (up to random iter). So, you dont need to fit objects
296	to be sure they are the same
297	'''
298	if ('id' not in kwargs) and ('name' not in kwargs or 'version' not in kwargs) \	×
299	and ('registered_name' not in kwargs or ('pipeline' not in kwargs and 'pipeline_kwargs' not in kwargs)):
300	raise TrainingError('Need to pass at least one of: `id`, `name, version`, `registered_name, pipeline`, `registered_name, pipeline_kwargs` to compare against existing persistables')	×
301
302	if 'id' in kwargs:	×
303	filters = {	×
304	'id': kwargs['id']
305	}
306
307	elif 'name' in kwargs and 'version' in kwargs:	×
308	filters = {	×
309	'name': kwargs['name'],
310	'version': kwargs['version'],
311	}
312
313	else:
314	pipeline = cls.retrieve_pipeline(**kwargs)	×
315	# Build dummy object to retrieve hash to look for
316	registered_name = kwargs['registered_name']	×
317	new_model = cls.retrieve_from_registry(registered_name)(**kwargs)	×
318	new_model.add_pipeline(pipeline)	×
319	if strict:	×
320	new_model.fit()	×
321
322	filters = {	×
323	'name': new_model.name,
324	'registered_name': new_model.registered_name,
325	'hash_': new_model._hash()
326	}
327
328	return Model, filters	×
329
330	@classmethod	6✔
331	def create(cls, registered_name, **kwargs):	2✔
332	'''
333	Stateless method to create a new persistable with the desired parameters
334	kwargs are passed directly to persistable
335
336	:param registered_name: Class name registered in SimpleML
337	:param pipeline: pipeline object
338	'''
339	pipeline = cls.retrieve_pipeline(**kwargs)	×
340	new_model = cls.retrieve_from_registry(registered_name)(**kwargs)	×
341	new_model.add_pipeline(pipeline)	×
342	new_model.fit()	×
343	new_model.save()	×
344
345	return new_model	×
346
347
348	class MetricCreator(PersistableCreator):	6✔
349	@classmethod	6✔
350	def determine_filters(cls, strict=False, **kwargs):	6✔
351	'''
352	stateless method to determine which filters to apply when looking for
353	existing persistable
354
355	Returns: database class, filter dictionary
356
357	:param registered_name: Class name registered in SimpleML
358	:param strict: whether to fit objects first before assuming they are identical
359	In theory if all inputs and classes are the same, the outputs should deterministically
360	be the same as well (up to random iter). So, you dont need to fit objects
361	to be sure they are the same
362	'''
363	if ('id' not in kwargs) and \	×
364	('name' not in kwargs or 'version' not in kwargs or ('model_id' not in kwargs and 'model' not in kwargs)) \
365	and ('registered_name' not in kwargs):
366	raise TrainingError('Need to pass at least one of: `id`, `name, version, model`, `name, version, model_id`, `registered_name` to compare against existing persistables')	×
367
368	model = cls.retrieve_model(**kwargs)	×
369	dataset = cls.retrieve_dataset(**kwargs)	×
370
371	if 'id' in kwargs:	×
372	filters = {	×
373	'id': kwargs['id']
374	}
375
376	elif 'name' in kwargs and 'version' in kwargs and model is not None:	×
377	filters = {	×
378	'name': kwargs['name'],
379	'version': kwargs['version'],
380	'model_id': model.id,
381	}
382
383	else:
384	# Build dummy object to retrieve hash to look for
385	registered_name = kwargs['registered_name']	×
386	new_metric = cls.retrieve_from_registry(registered_name)(**kwargs)	×
387	new_metric.add_model(model)	×
388	new_metric.add_dataset(dataset)	×
389	if strict:	×
390	new_metric.score()	×
391
392	filters = {	×
393	'name': new_metric.name,
394	'registered_name': registered_name,
395	'hash_': new_metric._hash()
396	}
397
398	return Metric, filters	×
399
400	@classmethod	6✔
401	def create(cls, registered_name, **kwargs):	2✔
402	'''
403	Stateless method to create a new persistable with the desired parameters
404	kwargs are passed directly to persistable
405
406	:param registered_name: Class name registered in SimpleML
407	:param model: model class
408	'''
409	model = cls.retrieve_model(**kwargs)	×
410	dataset = cls.retrieve_dataset(**kwargs)	×
411	new_metric = cls.retrieve_from_registry(registered_name)(**kwargs)	×
412	new_metric.add_model(model)	×
413	new_metric.add_dataset(dataset)	×
414	new_metric.score()	×
415	new_metric.save()	×
416
417	return new_metric	×

eyadgaran / SimpleML / 298

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous