def log_param(key, value):
"""
Logs the passed-in parameter under the current run, creating a run if necessary.
:param key: Parameter name (string)
:param value: Parameter value (string)
"""
_get_or_start_run().log_param(Param(key, str(value)))
def _log_param():
request_message = _get_request_message(LogParam())
param = Param(request_message.key, request_message.value)
_get_store().log_param(request_message.run_uuid, param)
response_message = LogParam.Response()
response = Response(mimetype='application/json')
response.set_data(_message_to_json(response_message))
return response
def test_weird_param_names(self):
WEIRD_PARAM_NAME = "this is/a weird/but valid param"
fs = FileStore(self.test_root)
run_uuid = self.exp_data[0]["runs"][0]
fs.log_param(run_uuid, Param(WEIRD_PARAM_NAME, "Value"))
param = fs.get_param(run_uuid, WEIRD_PARAM_NAME)
assert param.key == WEIRD_PARAM_NAME
assert param.value == "Value"
def _log_param():
request_message = _get_request_message(LogParam())
param = Param(request_message.key, request_message.value)
_get_store().log_param(request_message.run_uuid, param)
response_message = LogParam.Response()
response = Response(mimetype='application/json')
response.set_data(
MessageToJson(response_message, preserving_proto_field_name=True))
return response
def from_proto(cls, proto):
run_data = cls()
# iterate proto and add metrics and params
for proto_metric in proto.metrics:
run_data._add_metric(Metric.from_proto(proto_metric))
for proto_param in proto.params:
run_data._add_param(Param.from_proto(proto_param))
return run_data
def _get_param_from_file(parent_path, param_name):
param_data = read_file(parent_path, param_name)
if len(param_data) == 0:
raise Exception("Param '%s' is malformed. No data found." %
param_name)
if len(param_data) > 1:
raise Exception(
"Unexpected data for param '%s'. Param recorded more than once"
% param_name)
return Param(param_name, str(param_data[0].strip()))
def from_proto(cls, proto):
run_data = cls()
# iterate proto and add metrics, params, and tags
for proto_metric in proto.metrics:
run_data._add_metric(Metric.from_proto(proto_metric))
for proto_param in proto.params:
run_data._add_param(Param.from_proto(proto_param))
for proto_tag in proto.tags:
run_data._add_tag(RunTag.from_proto(proto_tag))
return run_data
def get_param(self, run_uuid, param_name):
"""
Returns the value of the specified parameter.
:param run_uuid: Unique identifier for run
:param param_name: Parameter name within the run
:return: Value of the given parameter if logged, else None
"""
req_body = _message_to_json(GetParam(run_uuid=run_uuid, param_name=param_name))
response_proto = self._call_endpoint(GetParam, req_body)
return Param.from_proto(response_proto.parameter)
def _run_project(project, entry_point, work_dir, parameters, use_conda,
storage_dir, experiment_id):
"""Locally run a project that has been checked out in `work_dir`."""
storage_dir_for_run = _get_storage_dir(storage_dir)
eprint(
"=== Created directory %s for downloading remote URIs passed to arguments of "
"type 'path' ===" % storage_dir_for_run)
# Try to build the command first in case the user mis-specified parameters
run_project_command = project.get_entry_point(entry_point)\
.compute_command(parameters, storage_dir_for_run)
commands = []
if use_conda:
conda_env_path = os.path.abspath(
os.path.join(work_dir, project.conda_env))
_maybe_create_conda_env(conda_env_path)
commands.append("source activate %s" %
_get_conda_env_name(conda_env_path))
# Create a new run and log every provided parameter into it.
active_run = tracking.start_run(
experiment_id=experiment_id,
source_name=project.uri,
source_version=tracking._get_git_commit(work_dir),
entry_point_name=entry_point,
source_type=SourceType.PROJECT)
if parameters is not None:
for key, value in parameters.items():
active_run.log_param(Param(key, value))
# Add the run id into a magic environment variable that the subprocess will read,
# causing it to reuse the run.
exp_id = experiment_id or tracking._get_experiment_id()
env_map = {
tracking._RUN_NAME_ENV_VAR: active_run.run_info.run_uuid,
tracking._TRACKING_URI_ENV_VAR: tracking.get_tracking_uri(),
tracking._EXPERIMENT_ID_ENV_VAR: str(exp_id),
}
commands.append(run_project_command)
command = " && ".join(commands)
eprint("=== Running command: %s ===" % command)
try:
process.exec_cmd([os.environ.get("SHELL", "bash"), "-c", command],
cwd=work_dir,
stream_output=True,
env=env_map)
tracking.end_run()
eprint("=== Run succeeded ===")
except process.ShellCommandException:
tracking.end_run("FAILED")
eprint("=== Run failed ===")
def _run_project(project, entry_point, work_dir, parameters, use_conda,
storage_dir, experiment_id):
"""Locally run a project that has been checked out in `work_dir`."""
mlflow.set_tracking_uri('..\\') #added by cliicy
if storage_dir is not None and not os.path.exists(storage_dir):
os.makedirs(storage_dir)
storage_dir_for_run = tempfile.mkdtemp(dir=storage_dir)
print(
"=== Created directory %s for downloading remote URIs passed to arguments of "
"type 'path' ===" % storage_dir_for_run)
# Try to build the command first in case the user mis-specified parameters
run_project_command = project.get_entry_point(entry_point).compute_command(
parameters, storage_dir_for_run)
commands = []
# Create a new run and log every provided parameter into it.
active_run = tracking.start_run(
experiment_id=experiment_id,
source_name=project.uri,
source_version=tracking._get_git_commit(work_dir),
entry_point_name=entry_point,
source_type=SourceType.PROJECT)
for key, value in parameters.items():
active_run.log_param(Param(key, value))
# Add the run id into a magic environment variable that the subprocess will read,
# causing it to reuse the run.
exp_id = experiment_id or tracking._get_experiment_id()
env_map = {
tracking._RUN_NAME_ENV_VAR: active_run.run_info.run_uuid,
tracking._TRACKING_URI_ENV_VAR: tracking.get_tracking_uri(),
tracking._EXPERIMENT_ID_ENV_VAR: str(exp_id),
}
commands.append(run_project_command)
command = " && ".join(commands)
print("=== Running command: %s ===" % command)
try:
command = "python my_train.py 0.4 0.1"
print("will run command aaaaa " + command + " " + work_dir + " aaaaa ")
process.exec_cmd(command,
cwd=work_dir,
stream_output=True,
env=env_map)
#process.exec_cmd([os.environ.get("SHELL", "bash"), "-c", command], cwd=work_dir,
# stream_output=True, env=env_map)
tracking.end_run()
print("=== Run succeeded ===")
except process.ShellCommandException:
tracking.end_run("FAILED")
print("=== Run failed ===")
def _create_run(uri, experiment_id, work_dir, entry_point, parameters):
"""
Create a ``Run`` against the current MLflow tracking server, logging metadata (e.g. the URI,
entry point, and parameters of the project) about the run. Return an ``ActiveRun`` that can be
used to report additional data about the run (metrics/params) to the tracking server.
"""
active_run = tracking._create_run(
experiment_id=experiment_id, source_name=_expand_uri(uri),
source_version=tracking._get_git_commit(work_dir), entry_point_name=entry_point,
source_type=SourceType.PROJECT)
if parameters is not None:
for key, value in parameters.items():
active_run.log_param(Param(key, value))
return active_run
def _create():
metrics = [
Metric(random_str(10), random_int(),
int(time.time() + random_int(-1e4, 1e4)))
for x in range(100)
] # noqa
params = [
Param(random_str(10), random_str(random_int(10, 35)))
for x in range(10)
] # noqa
rd = RunData()
for p in params:
rd.add_param(p)
for m in metrics:
rd.add_metric(m)
return rd, metrics, params
def _run_project(project, entry_point, work_dir, parameters, use_conda,
storage_dir, experiment_id, block):
"""Locally run a project that has been checked out in `work_dir`."""
storage_dir_for_run = _get_storage_dir(storage_dir)
eprint(
"=== Created directory %s for downloading remote URIs passed to arguments of "
"type 'path' ===" % storage_dir_for_run)
# Try to build the command first in case the user mis-specified parameters
run_project_command = project.get_entry_point(entry_point)\
.compute_command(parameters, storage_dir_for_run)
commands = []
if use_conda:
conda_env_path = os.path.abspath(
os.path.join(work_dir, project.conda_env))
_maybe_create_conda_env(conda_env_path)
commands.append("source activate %s" %
_get_conda_env_name(conda_env_path))
# Create a new run and log every provided parameter into it.
active_run = tracking._create_run(
experiment_id=experiment_id,
source_name=project.uri,
source_version=tracking._get_git_commit(work_dir),
entry_point_name=entry_point,
source_type=SourceType.PROJECT)
if parameters is not None:
for key, value in parameters.items():
active_run.log_param(Param(key, value))
# Add the run id into a magic environment variable that the subprocess will read,
# causing it to reuse the run.
env_map = {
tracking._RUN_ID_ENV_VAR: active_run.run_info.run_uuid,
tracking._TRACKING_URI_ENV_VAR: tracking.get_tracking_uri(),
tracking._EXPERIMENT_ID_ENV_VAR: str(experiment_id),
}
commands.append(run_project_command)
command = " && ".join(commands)
eprint("=== Running command '%s' in run with ID '%s' === " %
(command, active_run.run_info.run_uuid))
return _launch_local_run(active_run,
command,
work_dir,
env_map,
stream_output=block)
def _run_project(project, entry_point, work_dir, parameters, use_conda,
storage_dir, experiment_id):
"""Locally run a project that has been checked out in `work_dir`."""
if storage_dir is not None and not os.path.exists(storage_dir):
os.makedirs(storage_dir)
storage_dir_for_run = tempfile.mkdtemp(dir=storage_dir)
eprint(
"=== Created directory %s for downloading remote URIs passed to arguments of "
"type 'path' ===" % storage_dir_for_run)
# Try to build the command first in case the user mis-specified parameters
run_project_command = project.get_entry_point(entry_point)\
.compute_command(parameters, storage_dir_for_run)
commands = []
if use_conda:
with open(os.path.join(work_dir, project.conda_env)) as conda_env_file:
conda_env_sha = hashlib.sha1(
conda_env_file.read().encode("utf-8")).hexdigest()
conda_env = "mlflow-%s" % conda_env_sha
(exit_code, _, stderr) = process.exec_cmd(["conda", "--help"],
throw_on_error=False)
if exit_code != 0:
eprint(
'conda is not installed properly. Please follow the instructions on '
'https://conda.io/docs/user-guide/install/index.html')
eprint(stderr)
sys.exit(1)
(_, stdout,
stderr) = process.exec_cmd(["conda", "env", "list", "--json"])
env_names = [
os.path.basename(env) for env in json.loads(stdout)['envs']
]
conda_action = 'create'
if conda_env not in env_names:
eprint('=== Creating conda environment %s ===' % conda_env)
process.exec_cmd([
"conda", "env", conda_action, "-n", conda_env, "--file",
project.conda_env
],
cwd=work_dir,
stream_output=True)
commands.append("source activate %s" % conda_env)
# Create a new run and log every provided parameter into it.
active_run = tracking.start_run(
experiment_id=experiment_id,
source_name=project.uri,
source_version=tracking._get_git_commit(work_dir),
entry_point_name=entry_point,
source_type=SourceType.PROJECT)
for key, value in parameters.items():
active_run.log_param(Param(key, value))
# Add the run id into a magic environment variable that the subprocess will read,
# causing it to reuse the run.
exp_id = experiment_id or tracking._get_experiment_id()
env_map = {
tracking._RUN_NAME_ENV_VAR: active_run.run_info.run_uuid,
tracking._TRACKING_URI_ENV_VAR: tracking.get_tracking_uri(),
tracking._EXPERIMENT_ID_ENV_VAR: str(exp_id),
}
commands.append(run_project_command)
command = " && ".join(commands)
eprint("=== Running command: %s ===" % command)
try:
process.exec_cmd([os.environ.get("SHELL", "bash"), "-c", command],
cwd=work_dir,
stream_output=True,
env=env_map)
tracking.end_run()
eprint("=== Run succeeded ===")
except process.ShellCommandException:
tracking.end_run("FAILED")
eprint("=== Run failed ===")
def _add_param(self, param):
if isinstance(param, dict):
param = Param(param['key'], param['value'])
self._params.append(param)
