How to use the nni.tuner.Tuner function in nni

# Copyright (c) Microsoft Corporation.
# Licensed under the MIT license.

"""
SimpleTuner for Weight Sharing
"""

import logging

from threading import Event, Lock
from nni.tuner import Tuner

_logger = logging.getLogger('WeightSharingTuner')


class SimpleTuner(Tuner):
    """
    simple tuner, test for weight sharing
    """

    def __init__(self):
        super(SimpleTuner, self).__init__()
        self.trial_meta = {}
        self.f_id = None  # father
        self.sig_event = Event()
        self.thread_lock = Lock()

    def generate_parameters(self, parameter_id, **kwargs):
        if self.f_id is None:
            self.thread_lock.acquire()
            self.f_id = parameter_id
            self.trial_meta[parameter_id] = {

import time
from nni.tuner import Tuner


class MultiThreadTuner(Tuner):
    def __init__(self):
        self.parent_done = False

    def generate_parameters(self, parameter_id, **kwargs):
        if parameter_id == 0:
            return {'x': 0}
        else:
            while not self.parent_done:
                time.sleep(2)
            return {'x': 1}

    def receive_trial_result(self, parameter_id, parameters, value, **kwargs):
        if parameter_id == 0:
            self.parent_done = True

    def update_search_space(self, search_space):

# Licensed under the MIT license.

import json
import logging
import os

from nni.tuner import Tuner
from nni.utils import extract_scalar_reward

_logger = logging.getLogger('NaiveTuner')
_logger.info('start')

_pwd = os.path.dirname(__file__)
_result = open(os.path.join(_pwd, 'tuner_result.txt'), 'w')

class NaiveTuner(Tuner):
    def __init__(self, optimize_mode):
        self.cur = 0
        _logger.info('init')

    def generate_parameters(self, parameter_id, **kwargs):
        self.cur += 1
        _logger.info('generate parameters: %s' % self.cur)
        return { 'x': self.cur }

    def receive_trial_result(self, parameter_id, parameters, value, **kwargs):
        reward = extract_scalar_reward(value)
        _logger.info('receive trial result: %s, %s, %s' % (parameter_id, parameters, reward))
        _result.write('%d %d\n' % (parameters['x'], reward))
        _result.flush()

    def update_search_space(self, search_space):

import logging
import numpy as np

from sklearn.gaussian_process.kernels import Matern
from sklearn.gaussian_process import GaussianProcessRegressor

from nni.tuner import Tuner
from nni.utils import OptimizeMode, extract_scalar_reward

from .target_space import TargetSpace
from .util import UtilityFunction, acq_max

logger = logging.getLogger("GP_Tuner_AutoML")


class GPTuner(Tuner):
    """
    GPTuner is a Bayesian Optimization method where Gaussian Process is used for modeling loss functions.

    Parameters
    ----------
    optimize_mode : str
        optimize mode, 'maximize' or 'minimize', by default 'maximize'
    utility : str
        utility function (also called 'acquisition funcition') to use, which can be 'ei', 'ucb' or 'poi'. By default 'ei'.
    kappa : float
        value used by utility function 'ucb'. The bigger kappa is, the more the tuner will be exploratory. By default 5.
    xi : float
        used by utility function 'ei' and 'poi'. The bigger xi is, the more the tuner will be exploratory. By default 0.
    nu : float
        used to specify Matern kernel. The smaller nu, the less smooth the approximated function is. By default 2.5.
    alpha : float

from smac.facade.roar_facade import ROAR
from smac.facade.smac_facade import SMAC
from smac.scenario.scenario import Scenario
from smac.utils.io.cmd_reader import CMDReader

from ConfigSpaceNNI import Configuration

import nni
from nni.tuner import Tuner
from nni.utils import OptimizeMode, extract_scalar_reward

from .convert_ss_to_scenario import generate_scenario

logger = logging.getLogger('smac_AutoML')

class SMACTuner(Tuner):
    """
    This is a wrapper of [SMAC](https://github.com/automl/SMAC3) following NNI tuner interface.
    It only supports ``SMAC`` mode, and does not support the multiple instances of SMAC3 (i.e.,
    the same configuration is run multiple times).
    """
    def __init__(self, optimize_mode="maximize", config_dedup=False):
        """
        Parameters
        ----------
        optimize_mode : str
            Optimize mode, 'maximize' or 'minimize', by default 'maximize'
        config_dedup : bool
            If True, the tuner will not generate a configuration that has been already generated.
            If False, a configuration may be generated twice, but it is rare for relatively large search space.
        """
        self.logger = logger

import nni.metis_tuner.Regression_GP.CreateModel as gp_create_model
import nni.metis_tuner.Regression_GP.OutlierDetection as gp_outlier_detection
import nni.metis_tuner.Regression_GP.Prediction as gp_prediction
import nni.metis_tuner.Regression_GP.Selection as gp_selection
from nni.tuner import Tuner
from nni.utils import OptimizeMode, extract_scalar_reward

logger = logging.getLogger("Metis_Tuner_AutoML")

NONE_TYPE = ''
CONSTRAINT_LOWERBOUND = None
CONSTRAINT_UPPERBOUND = None
CONSTRAINT_PARAMS_IDX = []


class MetisTuner(Tuner):
    """
    Metis Tuner

    More algorithm information you could reference here:
    https://www.microsoft.com/en-us/research/publication/metis-robustly-tuning-tail-latencies-cloud-systems/

    Attributes
    ----------
        optimize_mode : str
            optimize_mode is a string that including two mode "maximize" and "minimize"

        no_resampling : bool
            True or False.
            Should Metis consider re-sampling as part of the search strategy?
            If you are confident that the training dataset is noise-free,
            then you do not need re-sampling.

def __str__(self):
        return "info: " + str(self.info) + ", config :" + str(self.config) + ", result: " + str(self.result)

    def mutation(self, indiv_id: int, graph_cfg: Graph = None, info=None):
        self.result = None
        if graph_cfg is not None:
            self.config = graph_cfg
        self.config.mutation()
        self.info = info
        self.parent_id = self.indiv_id
        self.indiv_id = indiv_id
        self.shared_ids.intersection_update({layer.hash_id for layer in self.config.layers if layer.is_delete is False})


class CustomerTuner(Tuner):
    """
    NAS Tuner using Evolution Algorithm, with weight sharing enabled
    """
    def __init__(self, optimize_mode, save_dir_root, population_size=32, graph_max_layer=6, graph_min_layer=3):
        self.optimize_mode = OptimizeMode(optimize_mode)
        self.indiv_counter = 0
        self.events = []
        self.thread_lock = Lock()
        self.save_dir_root = save_dir_root
        self.population = self.init_population(population_size, graph_max_layer, graph_min_layer)
        assert len(self.population) == population_size
        logger.debug('init population done.')
        return

    def generate_new_id(self):
        """

import numpy as np
from enum import Enum, unique

from nni.tuner import Tuner
from nni.utils import extract_scalar_reward

logger = logging.getLogger('autofe-tunner')



class OptimizeMode(Enum):
    Minimize = 'minimize'
    Maximize = 'maximize'


class BeamTuner(Tuner):
    def __init__(self, optimize_mode, feature_percent = 0.9, topk = 120):
        '''
        Beamsearch tunner used given default seacrch_space to get the top N features.
        '''
        self.count = -1
        self.optimize_mode = OptimizeMode(optimize_mode)
        # first trial feaure_importance
        self.search_space = None
        # deleted search_space
        self.deleta_feature = set([])
        # defautlt seach_space
        self.default_space = None 
        self.topk = topk
        self.feature_percent = feature_percent
        logger.debug('init aufo-fe done.')
        return

batch_tuner.py including:
    class BatchTuner
"""

import logging

import nni
from nni.tuner import Tuner

TYPE = '_type'
CHOICE = 'choice'
VALUE = '_value'

LOGGER = logging.getLogger('batch_tuner_AutoML')

class BatchTuner(Tuner):
    """
    BatchTuner is tuner will running all the configure that user want to run batchly.

    Examples
    --------
    The search space only be accepted like:

        ::

            {'combine_params':
                { '_type': 'choice',
                            '_value': '[{...}, {...}, {...}]',
                }
            }

    """

if choice_key == choice_name:
                        return {
                            NodeType.INDEX: pos,
                            NodeType.VALUE: [
                                choice_name,
                                _add_index(choice_value_format, parameter[1])
                            ]
                        }
                elif choice_name == item:
                    return {NodeType.INDEX: pos, NodeType.VALUE: item}
        else:
            return parameter
    return None  # note: this is not written by original author, feel free to modify if you think it's incorrect


class HyperoptTuner(Tuner):
    """
    HyperoptTuner is a tuner which using hyperopt algorithm.
    """

    def __init__(self, algorithm_name, optimize_mode='minimize',
                 parallel_optimize=False, constant_liar_type='min'):
        """
        Parameters
        ----------
        algorithm_name : str
            algorithm_name includes "tpe", "random_search" and anneal".
        optimize_mode : str
        parallel_optimize : bool
            More detail could reference: docs/en_US/Tuner/HyperoptTuner.md
        constant_liar_type : str
            constant_liar_type including "min", "max" and "mean"