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 []
