Coverage for mlos_core/mlos_core/optimizers/__init__.py: 96%

1# 

2# Copyright (c) Microsoft Corporation. 

3# Licensed under the MIT License. 

4# 

5"""Basic initializer module for the mlos_core optimizers.""" 

6 

7from enum import Enum 

8from typing import List, Optional, TypeVar 

9 

10import ConfigSpace 

11 

12from mlos_core.optimizers.bayesian_optimizers.smac_optimizer import SmacOptimizer 

13from mlos_core.optimizers.flaml_optimizer import FlamlOptimizer 

14from mlos_core.optimizers.optimizer import BaseOptimizer 

15from mlos_core.optimizers.random_optimizer import RandomOptimizer 

16from mlos_core.spaces.adapters import SpaceAdapterFactory, SpaceAdapterType 

17 

18__all__ = [ 

19 "SpaceAdapterType", 

20 "OptimizerFactory", 

21 "BaseOptimizer", 

22 "RandomOptimizer", 

23 "FlamlOptimizer", 

24 "SmacOptimizer", 

25] 

26 

27 

28class OptimizerType(Enum): 

29 """Enumerate supported MlosCore optimizers.""" 

30 

31 RANDOM = RandomOptimizer 

32 """An instance of RandomOptimizer class will be used.""" 

33 

34 FLAML = FlamlOptimizer 

35 """An instance of FlamlOptimizer class will be used.""" 

36 

37 SMAC = SmacOptimizer 

38 """An instance of SmacOptimizer class will be used.""" 

39 

40 

41# To make mypy happy, we need to define a type variable for each optimizer type. 

42# https://github.com/python/mypy/issues/12952 

43# ConcreteOptimizer = TypeVar('ConcreteOptimizer', *[member.value for member in OptimizerType]) 

44# To address this, we add a test for complete coverage of the enum. 

45ConcreteOptimizer = TypeVar( 

46 "ConcreteOptimizer", 

47 RandomOptimizer, 

48 FlamlOptimizer, 

49 SmacOptimizer, 

50) 

51 

52DEFAULT_OPTIMIZER_TYPE = OptimizerType.FLAML 

53 

54 

55class OptimizerFactory: 

56 """Simple factory class for creating BaseOptimizer-derived objects.""" 

57 

58 # pylint: disable=too-few-public-methods 

59 

60 @staticmethod 

61 def create( # pylint: disable=too-many-arguments 

62 *, 

63 parameter_space: ConfigSpace.ConfigurationSpace, 

64 optimization_targets: List[str], 

65 optimizer_type: OptimizerType = DEFAULT_OPTIMIZER_TYPE, 

66 optimizer_kwargs: Optional[dict] = None, 

67 space_adapter_type: SpaceAdapterType = SpaceAdapterType.IDENTITY, 

68 space_adapter_kwargs: Optional[dict] = None, 

69 ) -> ConcreteOptimizer: # type: ignore[type-var] 

70 """ 

71 Create a new optimizer instance, given the parameter space, optimizer type, and 

72 potential optimizer options. 

73 

74 Parameters 

75 ---------- 

76 parameter_space : ConfigSpace.ConfigurationSpace 

77 Input configuration space. 

78 optimization_targets : List[str] 

79 The names of the optimization targets to minimize. 

80 optimizer_type : OptimizerType 

81 Optimizer class as defined by Enum. 

82 optimizer_kwargs : Optional[dict] 

83 Optional arguments passed in Optimizer class constructor. 

84 space_adapter_type : Optional[SpaceAdapterType] 

85 Space adapter class to be used alongside the optimizer. 

86 space_adapter_kwargs : Optional[dict] 

87 Optional arguments passed in SpaceAdapter class constructor. 

88 

89 Returns 

90 ------- 

91 optimizer : ConcreteOptimizer 

92 Instance of concrete optimizer class 

93 (e.g., RandomOptimizer, FlamlOptimizer, SmacOptimizer, etc.). 

94 """ 

95 if space_adapter_kwargs is None: 

96 space_adapter_kwargs = {} 

97 if optimizer_kwargs is None: 

98 optimizer_kwargs = {} 

99 

100 space_adapter = SpaceAdapterFactory.create( 

101 parameter_space=parameter_space, 

102 space_adapter_type=space_adapter_type, 

103 space_adapter_kwargs=space_adapter_kwargs, 

104 ) 

105 

106 optimizer: ConcreteOptimizer = optimizer_type.value( 

107 parameter_space=parameter_space, 

108 optimization_targets=optimization_targets, 

109 space_adapter=space_adapter, 

110 **optimizer_kwargs, 

111 ) 

112 

113 return optimizer