def test_log_mpl_plotly(self):
assert (
os.path.exists(get_event_path(self.run_path, kind=V1ArtifactKind.CHART))
is False
)
assert (
os.path.exists(get_asset_path(self.run_path, kind=V1ArtifactKind.CHART))
is False
)
figure, axes = plt.figure(), plt.gca()
circle1 = plt.Circle((0.2, 0.5), 0.2, color="r")
circle2 = plt.Circle((0.8, 0.5), 0.2, color="g")
axes.add_patch(circle1)
axes.add_patch(circle2)
plt.axis("scaled")
plt.tight_layout()
with patch("polyaxon.tracking.run.Run._log_has_events") as log_dashboard:
self.run.log_mpl_plotly_chart(name="figure", figure=figure, step=1)
assert log_dashboard.call_count == 1
self.event_logger.flush()
assert (
os.path.exists(get_asset_path(self.run_path, kind=V1ArtifactKind.CHART))
is False
)
assert (
os.path.exists(get_event_path(self.run_path, kind=V1ArtifactKind.CHART))
is True
)
events_file = get_event_path(
self.run_path, kind=V1ArtifactKind.CHART, name="figure"
)
assert os.path.exists(events_file) is True
results = V1Events.read(kind="image", name="figure", data=events_file)
assert len(results.df.values) == 1
with patch("polyaxon.tracking.run.Run._log_has_events") as log_dashboard:
self.run.log_mpl_plotly_chart(name="figure", figure=figure, step=2)
assert log_dashboard.call_count == 1
assert plt.fignum_exists(figure.number) is False
self.event_logger.flush()
assert (
os.path.exists(get_asset_path(self.run_path, kind=V1ArtifactKind.CHART))
is False
)
assert (
os.path.exists(get_event_path(self.run_path, kind=V1ArtifactKind.CHART))
is True
)
events_file = get_event_path(
self.run_path, kind=V1ArtifactKind.CHART, name="figure"
)
assert os.path.exists(events_file) is True
results = V1Events.read(kind="image", name="figure", data=events_file)
assert len(results.df.values) == 2
def test_log_mpl_image(self):
assert (os.path.exists(
get_event_path(self.run_path, kind=V1ArtifactKind.IMAGE)) is False)
assert (os.path.exists(
get_asset_path(self.run_path, kind=V1ArtifactKind.IMAGE)) is False)
figure, axes = plt.figure(), plt.gca()
circle1 = plt.Circle((0.2, 0.5), 0.2, color="r")
circle2 = plt.Circle((0.8, 0.5), 0.2, color="g")
axes.add_patch(circle1)
axes.add_patch(circle2)
plt.axis("scaled")
plt.tight_layout()
self.run.log_mpl_image(name="figure", data=figure, step=1, close=False)
assert plt.fignum_exists(figure.number) is True
self.event_logger.flush()
assert (os.path.exists(
get_asset_path(self.run_path, kind=V1ArtifactKind.IMAGE)) is True)
assert (os.path.exists(
get_event_path(self.run_path, kind=V1ArtifactKind.IMAGE)) is True)
events_file = get_event_path(self.run_path,
kind=V1ArtifactKind.IMAGE,
name="figure")
assert os.path.exists(events_file) is True
results = V1Events.read(kind="image", name="figure", data=events_file)
assert len(results.df.values) == 1
asset_file = get_asset_path(self.run_path,
kind=V1ArtifactKind.IMAGE,
name="figure",
step=1,
ext="png")
assert os.path.exists(asset_file) is True
self.run.log_mpl_image(name="figure", data=figure, step=2)
assert plt.fignum_exists(figure.number) is False
self.event_logger.flush()
assert (os.path.exists(
get_asset_path(self.run_path, kind=V1ArtifactKind.IMAGE)) is True)
assert (os.path.exists(
get_event_path(self.run_path, kind=V1ArtifactKind.IMAGE)) is True)
events_file = get_event_path(self.run_path,
kind=V1ArtifactKind.IMAGE,
name="figure")
assert os.path.exists(events_file) is True
results = V1Events.read(kind="image", name="figure", data=events_file)
assert len(results.df.values) == 2
asset_file = get_asset_path(self.run_path,
kind=V1ArtifactKind.IMAGE,
name="figure",
step=1,
ext="png")
assert os.path.exists(asset_file) is True
def test_log_mpl_images(self):
assert (os.path.exists(
get_event_path(self.run_path, kind=V1ArtifactKind.IMAGE)) is False)
assert (os.path.exists(
get_asset_path(self.run_path, kind=V1ArtifactKind.IMAGE)) is False)
figures = []
for i in range(5):
figure = plt.figure()
plt.plot([i * 1, i * 2, i * 3], label="Plot " + str(i))
plt.xlabel("X")
plt.xlabel("Y")
plt.legend()
plt.tight_layout()
figures.append(figure)
self.run.log_mpl_image(name="figure",
data=figures,
step=1,
close=False)
assert all(
[plt.fignum_exists(figure.number) is True for figure in figures])
self.event_logger.flush()
assert (os.path.exists(
get_asset_path(self.run_path, kind=V1ArtifactKind.IMAGE)) is True)
assert (os.path.exists(
get_event_path(self.run_path, kind=V1ArtifactKind.IMAGE)) is True)
events_file = get_event_path(self.run_path,
kind=V1ArtifactKind.IMAGE,
name="figure")
assert os.path.exists(events_file) is True
results = V1Events.read(kind="image", name="figure", data=events_file)
assert len(results.df.values) == 1
self.run.log_mpl_image(name="figure", data=figures, step=2)
assert all(
[plt.fignum_exists(figure.number) is False for figure in figures])
self.event_logger.flush()
assert (os.path.exists(
get_asset_path(self.run_path, kind=V1ArtifactKind.IMAGE)) is True)
assert (os.path.exists(
get_event_path(self.run_path, kind=V1ArtifactKind.IMAGE)) is True)
events_file = get_event_path(self.run_path,
kind=V1ArtifactKind.IMAGE,
name="figure")
assert os.path.exists(events_file) is True
results = V1Events.read(kind="image", name="figure", data=events_file)
assert len(results.df.values) == 2
asset_file = get_asset_path(self.run_path,
kind=V1ArtifactKind.IMAGE,
name="figure",
step=1,
ext="png")
assert os.path.exists(asset_file) is True
def test_download_html_events_as_dict(self):
filepath1 = os.path.join(settings.CLIENT_CONFIG.archive_root, "uuid",
"events", "html", "html1.plx")
filepath2 = os.path.join(settings.CLIENT_CONFIG.archive_root, "uuid",
"events", "html", "html2.plx")
assert os.path.exists(filepath1) is False
assert os.path.exists(filepath2) is False
response = self.client.get(self.base_url +
"/html?names=html1&orient=dict")
assert response.status_code == 200
assert os.path.exists(filepath1) is True
assert os.path.exists(filepath2) is False
events1 = V1Events.read(name="html1",
kind=V1ArtifactKind.HTML,
data=filepath1,
parse_dates=False)
for res in response.json()["data"]:
assert isinstance(res["data"], dict)
results = [V1Events.read(**i) for i in response.json()["data"]]
assert results[0].name == events1.name
assert results[0].kind == events1.kind
assert pd.DataFrame.equals(results[0].df, events1.df)
response = self.client.get(self.base_url +
"/html?names=html1,html2&orient=dict")
assert response.status_code == 200
assert os.path.exists(filepath1) is True
assert os.path.exists(filepath2) is True
events2 = V1Events.read(name="html2",
kind=V1ArtifactKind.HTML,
data=filepath2,
parse_dates=False)
for res in response.json()["data"]:
assert isinstance(res["data"], dict)
results = [V1Events.read(**i) for i in response.json()["data"]]
expected = {events1.name: events1, events2.name: events2}
for res in results:
exp = expected[res.name]
assert res.name == exp.name
assert res.kind == exp.kind
assert pd.DataFrame.equals(res.df, exp.df)
response = self.client.get(self.base_url +
"/html?names=text1,html1,html2&orient=dict")
assert response.status_code == 200
assert os.path.exists(filepath1) is True
assert os.path.exists(filepath2) is True
for res in response.json()["data"]:
assert isinstance(res["data"], dict)
results = [V1Events.read(**i) for i in response.json()["data"]]
expected = {events1.name: events1, events2.name: events2}
for res in results:
exp = expected[res.name]
assert res.name == exp.name
assert res.kind == exp.kind
assert pd.DataFrame.equals(res.df, exp.df)
def test_download_text_events_as_csv(self):
filepath1 = os.path.join(settings.CLIENT_CONFIG.archive_root, "uuid",
"events", "text", "text1.plx")
filepath2 = os.path.join(settings.CLIENT_CONFIG.archive_root, "uuid",
"events", "text", "text2.plx")
assert os.path.exists(filepath1) is False
assert os.path.exists(filepath2) is False
response = self.client.get(self.base_url +
"/text?names=text1&orient=csv")
assert response.status_code == 200
assert os.path.exists(filepath1) is True
assert os.path.exists(filepath2) is False
events1 = V1Events.read(name="text1",
kind=V1ArtifactKind.TEXT,
data=filepath1)
for res in response.json()["data"]:
assert isinstance(res["data"], str)
results = [V1Events.read(**i) for i in response.json()["data"]]
assert results[0].name == events1.name
assert results[0].kind == events1.kind
assert pd.DataFrame.equals(results[0].df, events1.df)
response = self.client.get(self.base_url +
"/text?names=text1,text2&orient=csv")
assert response.status_code == 200
assert os.path.exists(filepath1) is True
assert os.path.exists(filepath2) is True
events2 = V1Events.read(name="text2",
kind=V1ArtifactKind.TEXT,
data=filepath2)
for res in response.json()["data"]:
assert isinstance(res["data"], str)
results = [V1Events.read(**i) for i in response.json()["data"]]
expected = {events1.name: events1, events2.name: events2}
for res in results:
exp = expected[res.name]
assert res.name == exp.name
assert res.kind == exp.kind
assert pd.DataFrame.equals(res.df, exp.df)
response = self.client.get(self.base_url +
"/text?names=text1,text2,text3&orient=csv")
assert response.status_code == 200
assert os.path.exists(filepath1) is True
assert os.path.exists(filepath2) is True
for res in response.json()["data"]:
assert isinstance(res["data"], str)
results = [V1Events.read(**i) for i in response.json()["data"]]
expected = {events1.name: events1, events2.name: events2}
for res in results:
exp = expected[res.name]
assert res.name == exp.name
assert res.kind == exp.kind
assert pd.DataFrame.equals(res.df, exp.df)
def test_log_charts(self):
x = [1, 2, 3, 4, 5]
y = [6, 7, 2, 4, 5]
bokeh_test = figure(title="simple line example",
x_axis_label="x",
y_axis_label="y")
bokeh_test.line(x, y, line_width=2)
x1 = np.random.randn(200) - 2
x2 = np.random.randn(200)
x3 = np.random.randn(200) + 2
hist_data = [x1, x2, x3]
group_labels = ["Group 1", "Group 2", "Group 3"]
plotly_test = figure_factory.create_distplot(hist_data,
group_labels,
bin_size=[0.1, 0.25, 0.5])
assert (os.path.exists(
get_event_path(self.run_path, kind=V1ArtifactKind.CHART)) is False)
assert (os.path.exists(
get_asset_path(self.run_path, kind=V1ArtifactKind.CHART)) is False)
self.run.log_bokeh_chart(name="bokeh_test", figure=bokeh_test, step=1)
self.run.log_plotly_chart(name="plotly_test",
figure=plotly_test,
step=1)
self.event_logger.flush()
assert (os.path.exists(
get_asset_path(self.run_path, kind=V1ArtifactKind.CHART)) is False)
assert (os.path.exists(
get_event_path(self.run_path, kind=V1ArtifactKind.CHART)) is True)
events_file = get_event_path(self.run_path,
kind=V1ArtifactKind.CHART,
name="bokeh_test")
assert os.path.exists(events_file) is True
results = V1Events.read(kind=V1ArtifactKind.CHART,
name="bokeh_test",
data=events_file)
assert len(results.df.values) == 1
events_file = get_event_path(self.run_path,
kind=V1ArtifactKind.CHART,
name="plotly_test")
assert os.path.exists(events_file) is True
results = V1Events.read(kind=V1ArtifactKind.CHART,
name="plotly_test",
data=events_file)
assert len(results.df.values) == 1
async def process_operation_event(
events_path: str,
event_kind: str,
event_name: str,
orient: str = V1Events.ORIENT_CSV,
) -> Optional[Dict]:
if not events_path or not os.path.exists(events_path):
return None
async with aiofiles.open(events_path, mode="r") as f:
contents = await f.read()
if contents:
if orient == V1Events.ORIENT_CSV:
return {
"name": event_name,
"kind": event_kind,
"data": contents
}
if orient == V1Events.ORIENT_DICT:
df = V1Events.read(kind=event_kind,
name=event_name,
data=contents,
parse_dates=False)
return {
"name": event_name,
"kind": event_kind,
"data": df.to_dict()
}
else:
raise HTTPException(
detail="received an unrecognisable orient value {}.".
format(orient),
status_code=status.HTTP_400_BAD_REQUEST,
)
return None
def test_images_read_yaml(self):
values = [
V1Event(
timestamp=parse_datetime("2018-12-11 10:24:57"),
image=V1EventImage(path="test"),
step=12,
),
V1Event(
timestamp=parse_datetime("2018-12-11 10:25:57"),
image=V1EventImage(height=1, width=1),
step=13,
),
V1Event(
timestamp=parse_datetime("2018-12-11 10:26:57"),
image=V1EventImage(height=10, width=10, colorspace=2),
step=14,
),
]
events = V1Events.read(
name="foo",
kind="image",
data=os.path.abspath("tests/fixtures/polyboard/image/image_events.plx"),
)
assert events.name == "foo"
assert len(events.df.values) == 3
for i in range(3):
assert events.get_event_at(i).to_dict() == values[i].to_dict()
def test_audios_read_yaml(self):
values = [
V1Event(
timestamp=parse_datetime("2018-12-11 10:24:57"),
audio=V1EventAudio(
sample_rate=1.1, num_channels=2, length_frames=2, path="test"
),
step=12,
),
V1Event(
timestamp=parse_datetime("2018-12-11 10:25:57"),
audio=V1EventAudio(
sample_rate=1.11,
num_channels=22,
length_frames=22,
path="test",
content_type="wav",
),
step=13,
),
V1Event(
timestamp=parse_datetime("2018-12-11 10:26:57"),
audio=V1EventAudio(path="testwave", content_type="wav"),
step=14,
),
]
events = V1Events.read(
name="foo",
kind="audio",
data=os.path.abspath("tests/fixtures/polyboard/audio/audio_events.plx"),
)
assert events.name == "foo"
assert len(events.df.values) == 3
for i in range(3):
assert events.get_event_at(i).to_dict() == values[i].to_dict()
def test_log_model_dir(self):
assert (os.path.exists(
get_event_path(self.run_path, kind=V1ArtifactKind.MODEL)) is False)
assert (os.path.exists(
get_asset_path(self.run_path, kind=V1ArtifactKind.MODEL)) is False)
model_dir = tempfile.mkdtemp() + "/model"
create_path(model_dir)
model_file = model_dir + "/model.pkl"
self.touch(model_file)
weights_file = model_dir + "/weights"
self.touch(weights_file)
configs_file = model_dir + "/configs"
self.touch(configs_file)
self.run.log_model(name="my_model",
path=model_dir,
framework="tensorflow")
self.event_logger.flush()
assert (os.path.exists(
get_asset_path(self.run_path, kind=V1ArtifactKind.MODEL)) is True)
assert (os.path.exists(
get_event_path(self.run_path, kind=V1ArtifactKind.MODEL)) is True)
events_file = get_event_path(self.run_path,
kind=V1ArtifactKind.MODEL,
name="my_model")
assert os.path.exists(events_file) is True
results = V1Events.read(kind="model",
name="my_model",
data=events_file)
assert len(results.df.values) == 1
asset_file = get_asset_path(self.run_path,
kind=V1ArtifactKind.MODEL,
name="my_model")
assert os.path.exists(asset_file) is True
def test_log_single_metric(self):
assert (
os.path.exists(get_event_path(self.run_path, kind=V1ArtifactKind.METRIC))
is False
)
assert (
os.path.exists(get_asset_path(self.run_path, kind=V1ArtifactKind.METRIC))
is False
)
with patch("polyaxon.tracking.run.Run._log_has_events") as log_dashboard:
self.run.log_metrics(step=1, metric1=1.1)
assert log_dashboard.call_count == 1
self.event_logger.flush()
assert (
os.path.exists(get_asset_path(self.run_path, kind=V1ArtifactKind.METRIC))
is False
)
assert (
os.path.exists(get_event_path(self.run_path, kind=V1ArtifactKind.METRIC))
is True
)
events_file = get_event_path(
self.run_path, kind=V1ArtifactKind.METRIC, name="metric1"
)
assert os.path.exists(events_file) is True
results = V1Events.read(kind="metric", name="metric1", data=events_file)
assert len(results.df.values) == 1
def test_htmls_read_yaml(self):
values = [
V1Event(
timestamp=dt_parser.parse("2018-12-11 10:24:57"),
html="<div>1</div>",
step=12,
),
V1Event(
timestamp=dt_parser.parse("2018-12-11 10:25:57"),
html="<div>2</div>",
step=13,
),
V1Event(
timestamp=dt_parser.parse("2018-12-11 10:26:57"),
html="<div>3</div>",
step=14,
),
]
events = V1Events.read(
name="foo",
kind="html",
data=os.path.abspath(
"tests/fixtures/polyboard/html/html_events.plx"),
)
assert events.name == "foo"
assert len(events.df.values) == 3
for i in range(3):
assert events.get_event_at(i).to_dict() == values[i].to_dict()
def test_artifacts_read_yaml(self):
values = [
V1Event(
timestamp=dt_parser.parse("2018-12-11 10:24:57"),
artifact=V1EventArtifact(kind="dataframe", path="path1"),
step=12,
),
V1Event(
timestamp=dt_parser.parse("2018-12-11 10:25:57"),
artifact=V1EventArtifact(kind="tsv", path="path2"),
step=13,
),
V1Event(
timestamp=dt_parser.parse("2018-12-11 10:26:57"),
artifact=V1EventArtifact(kind="csv", path="path3"),
step=14,
),
]
events = V1Events.read(
name="foo",
kind="artifact",
data=os.path.abspath(
"tests/fixtures/polyboard/artifact/artifact_events.plx"),
)
assert events.name == "foo"
assert len(events.df.values) == 3
for i in range(3):
assert events.get_event_at(i).to_dict() == values[i].to_dict()
def test_log_text(self):
assert (
os.path.exists(get_event_path(self.run_path, kind=V1ArtifactKind.TEXT))
is False
)
assert (
os.path.exists(get_asset_path(self.run_path, kind=V1ArtifactKind.TEXT))
is False
)
with patch("polyaxon.tracking.run.Run._log_has_events") as log_dashboard:
self.run.log_text(name="my_text", text="some text", step=1)
assert log_dashboard.call_count == 1
self.event_logger.flush()
assert (
os.path.exists(get_asset_path(self.run_path, kind=V1ArtifactKind.TEXT))
is False
)
assert (
os.path.exists(get_event_path(self.run_path, kind=V1ArtifactKind.TEXT))
is True
)
events_file = get_event_path(
self.run_path, kind=V1ArtifactKind.TEXT, name="my_text"
)
assert os.path.exists(events_file) is True
results = V1Events.read(kind="text", name="my_text", data=events_file)
assert len(results.df.values) == 1
def test_log_html(self):
assert (
os.path.exists(get_event_path(self.run_path, kind=V1ArtifactKind.HTML))
is False
)
assert (
os.path.exists(get_asset_path(self.run_path, kind=V1ArtifactKind.HTML))
is False
)
with patch("polyaxon.tracking.run.Run._log_has_events") as log_dashboard:
self.run.log_html(name="my_div", html="<div>test<div/>", step=1)
assert log_dashboard.call_count == 1
self.event_logger.flush()
assert (
os.path.exists(get_asset_path(self.run_path, kind=V1ArtifactKind.HTML))
is False
)
assert (
os.path.exists(get_event_path(self.run_path, kind=V1ArtifactKind.HTML))
is True
)
events_file = get_event_path(
self.run_path, kind=V1ArtifactKind.HTML, name="my_div"
)
assert os.path.exists(events_file) is True
results = V1Events.read(kind="html", name="my_div", data=events_file)
assert len(results.df.values) == 1
def test_log_video_from_path(self):
assert (
os.path.exists(get_event_path(self.run_path, kind=V1ArtifactKind.VIDEO))
is False
)
assert (
os.path.exists(get_asset_path(self.run_path, kind=V1ArtifactKind.VIDEO))
is False
)
video_file = tempfile.mkdtemp() + "/video.gif"
self.touch(video_file)
with patch("polyaxon.tracking.run.Run._log_has_events") as log_dashboard:
self.run.log_video(name="my_video", data=video_file)
assert log_dashboard.call_count == 1
self.event_logger.flush()
assert (
os.path.exists(get_asset_path(self.run_path, kind=V1ArtifactKind.VIDEO))
is True
)
assert (
os.path.exists(get_event_path(self.run_path, kind=V1ArtifactKind.VIDEO))
is True
)
events_file = get_event_path(
self.run_path, kind=V1ArtifactKind.VIDEO, name="my_video"
)
assert os.path.exists(events_file) is True
results = V1Events.read(kind="video", name="my_video", data=events_file)
assert len(results.df.values) == 1
asset_file = get_asset_path(
self.run_path, kind=V1ArtifactKind.VIDEO, name="my_video", ext="gif"
)
assert os.path.exists(asset_file) is True
def test_log_data_audio(self):
assert (
os.path.exists(get_event_path(self.run_path, kind=V1ArtifactKind.AUDIO))
is False
)
assert (
os.path.exists(get_asset_path(self.run_path, kind=V1ArtifactKind.AUDIO))
is False
)
with patch("polyaxon.tracking.run.Run._log_has_events") as log_dashboard:
self.run.log_audio(name="my_audio", data=tensor_np(shape=(42,)))
assert log_dashboard.call_count == 1
self.event_logger.flush()
assert (
os.path.exists(get_asset_path(self.run_path, kind=V1ArtifactKind.AUDIO))
is True
)
assert (
os.path.exists(get_event_path(self.run_path, kind=V1ArtifactKind.AUDIO))
is True
)
events_file = get_event_path(
self.run_path, kind=V1ArtifactKind.AUDIO, name="my_audio"
)
assert os.path.exists(events_file) is True
results = V1Events.read(kind="audio", name="my_audio", data=events_file)
assert len(results.df.values) == 1
asset_file = get_asset_path(
self.run_path, kind=V1ArtifactKind.AUDIO, name="my_audio", ext="wav"
)
assert os.path.exists(asset_file) is True
def test_log_artifact(self):
assert (os.path.exists(
get_event_path(self.run_path, kind=V1ArtifactKind.TSV)) is False)
assert (os.path.exists(
get_asset_path(self.run_path, kind=V1ArtifactKind.TSV)) is False)
tsv_file = tempfile.mkdtemp() + "/file.tsv"
self.touch(tsv_file)
self.run.log_artifact(name="file",
path=tsv_file,
artifact_kind=V1ArtifactKind.TSV)
self.event_logger.flush()
assert (os.path.exists(
get_asset_path(self.run_path, kind=V1ArtifactKind.TSV)) is True)
assert (os.path.exists(
get_event_path(self.run_path, kind=V1ArtifactKind.TSV)) is True)
events_file = get_event_path(self.run_path,
kind=V1ArtifactKind.TSV,
name="file")
assert os.path.exists(events_file) is True
results = V1Events.read(kind=V1ArtifactKind.TSV,
name="file",
data=events_file)
assert len(results.df.values) == 1
asset_file = get_asset_path(self.run_path,
kind=V1ArtifactKind.TSV,
name="file",
ext="tsv")
assert os.path.exists(asset_file) is True
def test_log_data_image(self):
assert (
os.path.exists(get_event_path(self.run_path, kind=V1ArtifactKind.IMAGE))
is False
)
assert (
os.path.exists(get_asset_path(self.run_path, kind=V1ArtifactKind.IMAGE))
is False
)
with patch("polyaxon.tracking.run.Run._log_has_events") as log_dashboard:
self.run.log_image(
name="my_image", data=tensor_np(shape=(1, 8, 8)), dataformats="CHW"
)
assert log_dashboard.call_count == 1
self.event_logger.flush()
assert (
os.path.exists(get_asset_path(self.run_path, kind=V1ArtifactKind.IMAGE))
is True
)
assert (
os.path.exists(get_event_path(self.run_path, kind=V1ArtifactKind.IMAGE))
is True
)
events_file = get_event_path(
self.run_path, kind=V1ArtifactKind.IMAGE, name="my_image"
)
assert os.path.exists(events_file) is True
results = V1Events.read(kind="image", name="my_image", data=events_file)
assert len(results.df.values) == 1
asset_file = get_asset_path(
self.run_path, kind=V1ArtifactKind.IMAGE, name="my_image", ext="png"
)
assert os.path.exists(asset_file) is True
def test_log_image_from_path_with_step(self):
assert (
os.path.exists(get_event_path(self.run_path, kind=V1ArtifactKind.IMAGE))
is False
)
assert (
os.path.exists(get_asset_path(self.run_path, kind=V1ArtifactKind.IMAGE))
is False
)
image_file = tempfile.mkdtemp() + "/file.png"
self.touch(image_file)
with patch("polyaxon.tracking.run.Run._log_has_events") as log_dashboard:
self.run.log_image(name="my_image", data=image_file, step=1)
assert log_dashboard.call_count == 1
self.event_logger.flush()
assert (
os.path.exists(get_asset_path(self.run_path, kind=V1ArtifactKind.IMAGE))
is True
)
assert (
os.path.exists(get_event_path(self.run_path, kind=V1ArtifactKind.IMAGE))
is True
)
events_file = get_event_path(
self.run_path, kind=V1ArtifactKind.IMAGE, name="my_image"
)
assert os.path.exists(events_file) is True
results = V1Events.read(kind="image", name="my_image", data=events_file)
assert len(results.df.values) == 1
asset_file = get_asset_path(
self.run_path, kind=V1ArtifactKind.IMAGE, name="my_image", step=1, ext="png"
)
assert os.path.exists(asset_file) is True
def test_histograms_read_yaml(self):
values = [
V1Event(
timestamp=dt_parser.parse("2018-12-11 10:24:57"),
histogram=V1EventHistogram(values=[10], counts=[1]),
step=12,
),
V1Event(
timestamp=dt_parser.parse("2018-12-11 10:25:57"),
histogram=V1EventHistogram(values=[10, 1, 1], counts=[1, 1,
1]),
step=13,
),
V1Event(
timestamp=dt_parser.parse("2018-12-11 10:26:57"),
histogram=V1EventHistogram(values=[10, 112, 12, 1],
counts=[12, 1, 1, 1]),
step=14,
),
]
events = V1Events.read(
name="foo",
kind="histogram",
data=os.path.abspath(
"tests/fixtures/polyboard/histogram/histogram_events.plx"),
)
assert events.name == "foo"
assert len(events.df.values) == 3
for i in range(3):
assert events.get_event_at(i).to_dict() == values[i].to_dict()
def test_log_dataframe(self):
assert (os.path.exists(
get_event_path(self.run_path, kind=V1ArtifactKind.DATAFRAME)) is
False)
assert (os.path.exists(
get_asset_path(self.run_path, kind=V1ArtifactKind.DATAFRAME)) is
False)
model_file = tempfile.mkdtemp() + "/df.pkl"
self.touch(model_file)
self.run.log_dataframe(name="dataframe",
path=model_file,
content_type="pickel")
self.event_logger.flush()
assert (os.path.exists(
get_asset_path(self.run_path, kind=V1ArtifactKind.DATAFRAME)) is
True)
assert (os.path.exists(
get_event_path(self.run_path, kind=V1ArtifactKind.DATAFRAME)) is
True)
events_file = get_event_path(self.run_path,
kind=V1ArtifactKind.DATAFRAME,
name="dataframe")
assert os.path.exists(events_file) is True
results = V1Events.read(kind="dataframe",
name="dataframe",
data=events_file)
assert len(results.df.values) == 1
asset_file = get_asset_path(self.run_path,
kind=V1ArtifactKind.DATAFRAME,
name="dataframe",
ext="pkl")
assert os.path.exists(asset_file) is True
def test_videos_read_yaml(self):
values = [
V1Event(
timestamp=dt_parser.parse("2018-12-11 10:24:57"),
video=V1EventVideo(path="test", content_type="mp4"),
step=12,
),
V1Event(
timestamp=dt_parser.parse("2018-12-11 10:25:57"),
video=V1EventVideo(height=1, width=1),
step=13,
),
V1Event(
timestamp=dt_parser.parse("2018-12-11 10:26:57"),
video=V1EventVideo(height=10, width=10, colorspace=2),
step=14,
),
]
events = V1Events.read(
name="foo",
kind="video",
data=os.path.abspath(
"tests/fixtures/polyboard/video/video_events.plx"),
)
assert events.name == "foo"
assert len(events.df.values) == 3
for i in range(3):
assert events.get_event_at(i).to_dict() == values[i].to_dict()
def test_log_np_histogram(self):
assert (
os.path.exists(get_event_path(self.run_path, kind=V1ArtifactKind.HISTOGRAM))
is False
)
assert (
os.path.exists(get_asset_path(self.run_path, kind=V1ArtifactKind.HISTOGRAM))
is False
)
values, counts = np.histogram(np.random.randint(255, size=(1000,)))
with patch("polyaxon.tracking.run.Run._log_has_events") as log_dashboard:
self.run.log_np_histogram(
name="histo", values=values, counts=counts, step=1
)
assert log_dashboard.call_count == 1
self.event_logger.flush()
assert (
os.path.exists(get_asset_path(self.run_path, kind=V1ArtifactKind.HISTOGRAM))
is False
)
assert (
os.path.exists(get_event_path(self.run_path, kind=V1ArtifactKind.HISTOGRAM))
is True
)
events_file = get_event_path(
self.run_path, kind=V1ArtifactKind.HISTOGRAM, name="histo"
)
assert os.path.exists(events_file) is True
results = V1Events.read(kind="histogram", name="histo", data=events_file)
assert len(results.df.values) == 1
def test_charts_read_yaml(self):
values = [
V1Event(
timestamp=dt_parser.parse("2018-12-11 10:24:57"),
chart=V1EventChart(kind="plotly", figure={"foo": "bar"}),
step=12,
),
V1Event(
timestamp=dt_parser.parse("2018-12-11 10:25:57"),
chart=V1EventChart(kind="vega", figure={"foo2": "bar2"}),
step=13,
),
V1Event(
timestamp=dt_parser.parse("2018-12-11 10:26:57"),
chart=V1EventChart(kind="bokeh", figure={"foo3": "bar3"}),
step=14,
),
]
events = V1Events.read(
name="foo",
kind="chart",
data=os.path.abspath(
"tests/fixtures/polyboard/chart/chart_events.plx"),
)
assert events.name == "foo"
assert len(events.df.values) == 3
for i in range(3):
assert events.get_event_at(i).to_dict() == values[i].to_dict()
def test_log_model_file(self):
assert (
os.path.exists(get_event_path(self.run_path, kind=V1ArtifactKind.MODEL))
is False
)
assert (
os.path.exists(get_asset_path(self.run_path, kind=V1ArtifactKind.MODEL))
is False
)
model_file = tempfile.mkdtemp() + "model.pkl"
self.touch(model_file)
with patch("polyaxon.tracking.run.Run._log_has_model") as log_model:
self.run.log_model(name="my_model", path=model_file, framework="scikit")
assert log_model.call_count == 1
self.event_logger.flush()
assert (
os.path.exists(get_asset_path(self.run_path, kind=V1ArtifactKind.MODEL))
is True
)
assert (
os.path.exists(get_event_path(self.run_path, kind=V1ArtifactKind.MODEL))
is True
)
events_file = get_event_path(
self.run_path, kind=V1ArtifactKind.MODEL, name="my_model"
)
assert os.path.exists(events_file) is True
results = V1Events.read(kind="model", name="my_model", data=events_file)
assert len(results.df.values) == 1
asset_file = get_asset_path(
self.run_path, kind=V1ArtifactKind.MODEL, name="my_model", ext="pkl"
)
assert os.path.exists(asset_file) is True
def test_dataframes_read_yaml(self):
values = [
V1Event(
timestamp=dt_parser.parse("2018-12-11 10:24:57"),
dataframe=V1EventDataframe(path="path1",
content_type="parquet"),
step=12,
),
V1Event(
timestamp=dt_parser.parse("2018-12-11 10:25:57"),
dataframe=V1EventDataframe(path="path2",
content_type="pickle"),
step=13,
),
V1Event(
timestamp=dt_parser.parse("2018-12-11 10:26:57"),
dataframe=V1EventDataframe(path="path3"),
step=14,
),
]
events = V1Events.read(
name="foo",
kind="dataframe",
data=os.path.abspath(
"tests/fixtures/polyboard/dataframe/dataframe_events.plx"),
)
assert events.name == "foo"
assert len(events.df.values) == 3
for i in range(3):
assert events.get_event_at(i).to_dict() == values[i].to_dict()
def test_histograms_summaries(self):
summaries, last_values = sync_events_summaries(
events_path="tests/fixtures/polyboard",
events_kind="histogram",
last_check=None,
)
events = V1Events.read(
name="histogram_events",
kind="histogram",
data=os.path.abspath(
"tests/fixtures/polyboard/histogram/histogram_events.plx"),
)
assert events.name == "histogram_events"
assert summaries == [
V1RunArtifact(
name="histogram_events",
kind="histogram",
connection=None,
summary=events.get_summary(),
path=os.path.relpath(
"tests/fixtures/polyboard/histogram/histogram_events.plx",
CONTEXT_MOUNT_ARTIFACTS,
),
is_input=False,
)
]
assert last_values == {}
def test_log_histogram(self):
assert (
os.path.exists(get_event_path(self.run_path, kind=V1ArtifactKind.HISTOGRAM))
is False
)
assert (
os.path.exists(get_asset_path(self.run_path, kind=V1ArtifactKind.HISTOGRAM))
is False
)
with patch("polyaxon.tracking.run.Run._log_has_events") as log_dashboard:
self.run.log_histogram(
name="histo", values=tensor_np(shape=(1024,)), bins="auto", step=1
)
self.run.log_histogram(
name="histo", values=tensor_np(shape=(1024,)), bins="fd", step=1
)
self.run.log_histogram(
name="histo", values=tensor_np(shape=(1024,)), bins="doane", step=1
)
assert log_dashboard.call_count == 3
self.event_logger.flush()
assert (
os.path.exists(get_asset_path(self.run_path, kind=V1ArtifactKind.HISTOGRAM))
is False
)
assert (
os.path.exists(get_event_path(self.run_path, kind=V1ArtifactKind.HISTOGRAM))
is True
)
events_file = get_event_path(
self.run_path, kind=V1ArtifactKind.HISTOGRAM, name="histo"
)
assert os.path.exists(events_file) is True
results = V1Events.read(kind="histogram", name="histo", data=events_file)
assert len(results.df.values) == 3
def test_models_read_yaml(self):
values = [
V1Event(
timestamp=dt_parser.parse("2018-12-11 10:24:57"),
model=V1EventModel(framework="tensorflow", path="path1"),
step=12,
),
V1Event(
timestamp=dt_parser.parse("2018-12-11 10:25:57"),
model=V1EventModel(framework="pytorch", path="path2"),
step=13,
),
V1Event(
timestamp=dt_parser.parse("2018-12-11 10:26:57"),
model=V1EventModel(framework="onnx", path="path3"),
step=14,
),
]
events = V1Events.read(
name="foo",
kind="model",
data=os.path.abspath("tests/fixtures/polyboard/model/model_events.plx"),
)
assert events.name == "foo"
assert len(events.df.values) == 3
for i in range(3):
assert events.get_event_at(i).to_dict() == values[i].to_dict()
