def log_json(self, obj: Union[EntryModel, dict]): """ Logs a single given object as the json object representing the repository object. :param obj: Object to store as json. storage_type gets set to the respective repository name value :return: """ if isinstance(obj, dict): obj = RepositoryEntryModel(**self._extend_meta({ **obj, **self.reference_dict() })) else: if hasattr(obj, "experiment"): obj.experiment = get_reference( ExperimentModel(uid=self.repository.id, name=self.repository.name)) if hasattr(obj, "run"): obj.run = get_reference(RunModel(uid=str(self.run_id))) obj = RepositoryEntryModel(**self._extend_meta({ **obj.dict(by_alias=True), **self.reference_dict() })) if isinstance(self.pads.backend, MongoSupportMixin): return self.pads.backend.log_json(obj) else: with self.init_context() as ctx: return self.pads.backend.log(obj)
def get(self, uid, storage_type: Union[str, ResultType], experiment_name=None, experiment_id=None, run_id=None, search_dict=None): """ Get result entry with given type and uid. :param uid: :param search_dict: :param experiment_id: :param experiment_name: :param run_id: :param storage_type: :return: """ reference = IdReference(uid=uid, storage_type=storage_type, experiment=get_reference( ExperimentModel(uid=experiment_id, name=experiment_name)), run=get_reference( RunModel(uid=str(self.run_id))), backend_uri=self.uri) json_data = self.get_json(reference) if storage_type == ResultType.artifact: return Artifact(**dict(json_data)) else: return json_data
def typed_id(self): cls = self.get_model_cls() if issubclass(cls, BaseStorageModel): return get_reference(self) else: raise Exception( f"Can't extract typed id: Model {str(cls)} is not an IdBasedEntry." )
def get_reference(self): """ Function to build a reference to the repository object. (And it's internal singular json) :return: """ reference = self.repository.repo_reference(self.uid) reference.run = get_reference(RunModel(uid=str(self.run_id))) return reference
def test_track_artifact(self): # --------------------------- setup of the tracking --------------------------- # Activate tracking of pypads from pypads.app.base import PyPads tracker = PyPads(uri=TEST_FOLDER, autostart=True) import os import pickle as pkl import numpy as np name = 'some_artifact.pickle' path = os.path.join(os.getcwd(), name) description = 'logging an artifact from a local path' obj = np.random.random(size=(3, 3)) keys = [ 'experiment_id', 'run_id', 'category', 'storage_type', 'description', 'name', 'description', 'produced_by' ] with open(path, 'wb') as f: pkl.dump(obj, f) tracker.api.log_artifact(local_path=path, additional_data=None, holder=None, description=description) os.remove(path=path) holder = tracker.api.get_programmatic_output() meta = ArtifactMetaModel(value_format='str', file_format=FileFormats.pickle, description=description, file_size=229, data=str(obj), parent=holder, produced_by=holder.produced_by, part_of=get_reference(holder)) # Load the artifacts artifacts = [ x for x in tracker.results.get_artifacts(run_id=meta.run.uid) if x.data == name ] # Load the data from the pypads path loaded_data = tracker.results.load_artifact( name, read_format=FileFormats.pickle) # --------------------------- asserts --------------------------- assert bool((loaded_data == obj).all()) is True assert len(artifacts) == 1 artifacts = artifacts[0] for key in keys: assert meta.dict().get(key) == artifacts.dict().get(key)
def __init__(self, *args, logging_env: LoggerEnv, output=None, creator: LoggerModel, **kwargs): super().__init__(*args, output=output, **kwargs) self.creator = creator self.created_by = get_reference(self.creator) self._logging_env = logging_env
def repo_reference(self, uid, run_id=-1): """ Translates a uid in a uid hash with the repos meta information. :param run_id: :param uid: :return: """ return to_reference({ "uid": uid, "storage_type": self.name, "experiment": get_reference(ExperimentModel(uid=self.id, name=self.name)), "backend_uri": self.pads.backend.uri, "run": get_reference(RunModel(uid=str(run_id))), # The run_id is here not important the run doesn't exist right now "category": self.name })
def reference_dict(self): """ Dict of the repo object to extend the passed json on. :return: """ return { "uid": self.uid, "repository": self.repo_reference, "storage_type": self.repository.name, "experiment": get_reference( ExperimentModel(uid=self.repository.id, name=self.repository.name)), "backend_uri": self.pads.backend.uri, "run": get_reference(RunModel(uid=str(self.run_id))), # The run_id is here not important the run doesn't exist right now "category": self.repository.name }
def test_track_mem_artifact(self): # --------------------------- setup of the tracking --------------------------- # Activate tracking of pypads from pypads.app.base import PyPads tracker = PyPads(uri=TEST_FOLDER, autostart=True) path = 'some_artifact' description = 'Storing test array as an artifact' keys = [ 'experiment_id', 'run_id', 'category', 'storage_type', 'description', 'name', 'description', 'produced_by' ] import numpy as np obj = np.random.random(size=(3, 3)) holder = tracker.api.get_programmatic_output() tracker.api.log_mem_artifact(path=path, obj=obj, write_format=FileFormats.pickle, description=description, additional_data=None, holder=None) meta = ArtifactMetaModel(value_format='str', file_format=FileFormats.pickle, description=description, file_size=229, data=str(obj), parent=holder, produced_by=holder.produced_by, part_of=get_reference(holder)) artifacts = [ x for x in tracker.results.get_artifacts(run_id=meta.run.uid) if x.data == path + '.pickle' ] # --------------------------- asserts --------------------------- assert len(artifacts) == 1 artifacts = artifacts[0] for key in keys: assert meta.dict().get(key) == artifacts.dict().get(key)
def test_track_metric(self): # --------------------------- setup of the tracking --------------------------- # Activate tracking of pypads from pypads.app.base import PyPads name = "some_metric" description = 'Some description' value = 1 step = 0 keys = [ 'experiment_id', 'run_id', 'category', 'storage_type', 'description', 'name', 'data' ] tracker = PyPads(uri=TEST_FOLDER) tracker.activate_tracking() tracker.start_track(experiment_name='TEST CASE EXPERIMENT') # meta = MetricMetaModel(url='https://some.metric.url', name='some_metric', description='some description', # step=0) tracker.api.log_metric(name, value=value, description=description, step=step) holder = tracker.api.get_programmatic_output() meta = MetricMetaModel(name=name, value_format='str', data=str(value), step=step, description=description, parent=holder, produced_by=holder.produced_by, part_of=get_reference(holder)) artifacts = [ x for x in tracker.results.get_metrics( experiment_name='TEST CASE EXPERIMENT', name=name, step=step, run_id=meta.run.uid) ] # --------------------------- asserts --------------------------- assert len(artifacts) == 1 for key in keys: assert artifacts[0].dict().get(key) == meta.dict().get(key)
def test_track_param(self): # --------------------------- setup of the tracking --------------------------- # Activate tracking of pypads from pypads.app.base import PyPads name = 'networks_shape' neural_network_shape = [10, 10, 3] description = 'Shape of the fully connected network' keys = ['experiment_id', 'run_id', 'category', 'storage_type'] tracker = PyPads(uri=TEST_FOLDER, autostart=True) tracker.api.log_param(key=name, value=str(neural_network_shape), description=description) holder = tracker.api.get_programmatic_output() meta = ParameterMetaModel(name=name, value_format='str', data=str(neural_network_shape), description=description, parent=holder, produced_by=holder.produced_by, part_of=get_reference(holder)) # --------------------------- asserts --------------------------- # Number of retrieved items should be 1 retrieved_items = [ x for x in tracker.results.get_parameters(name='networks_shape', run_id=meta.run.uid) ] assert len(retrieved_items) == 1 retrieved_items = retrieved_items[0] for key in keys: assert retrieved_items.dict().get(key) == meta.dict().get(key)
def artifacts(self): return [ get_reference(a, validate=False) for a in self._results[ResultType.artifact] ] if ResultType.artifact in self._results else []
def tags(self): return [ get_reference(a, validate=False) for a in self._results[ResultType.tag] ] if ResultType.tag in self._results else []
def metrics(self): return [ get_reference(a, validate=False) for a in self._results[ResultType.metric] ] if ResultType.metric in self._results else []
def tracked_objects(self): return [ get_reference(a, validate=False) for a in self._results[ResultType.tracked_object] ] if ResultType.tracked_object in self._results else []
def part_of(self: Union['ChildResultMixin', ResultModel]): return get_reference(self.parent)
def produced_by(self: Union['ProducedMixin', ProducedModel]): return get_reference(self._producer)
def parameters(self): return [ get_reference(a, validate=False) for a in self._results[ResultType.parameter] ] if ResultType.parameter in self._results else []