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)