Skip to content

learning

Module diagram

classDiagram
  class learning {
  }
  class device {
  }
  class meter {
  }
  class optimizer {
  }
  class scheduler {
  }
  class trainer {
  }
  scheduler --> optimizer

learning

Device manager 및 기본적인 metric 관리 클래스와 기본 Trainer 클래스를 제공합니다.

BaseTrainer 클래스는 Saige Vision2 Engine 학습 API의 베이스 인터페이스를 제공하며, 이를 상속받아 사용자 정의 Trainer를 구현할 수 있습니다. 구현 메서드들은 error_handler를 씌워 노출되어야 합니다.

device

"Device Manager, converting modules and data tensors to device

AttributeDataParallel

Bases: DataParallel

DataParallel class with attribute get method.

You can now use expressions like:

Possible with origial DataParallel class.

... self.network(x) ... # Not possible with origial DataParallel class. ... self.network.feature_extractor(x)

...where self.network is a AttributeDataParallel class instance.

Author

Jonghyuk Baek

DeviceManager 

DeviceManager(device: DeviceType = 'cpu', multi_gpu: bool = False)

converting torch.nn.modules and torch.tensors to selected device.

Attributes:

  • device (device) –

    name of target device for learning.

  • multi_gpu (bool) –

    whether use multi-gpu learning.

initializing DeviceManager

Parameters:

  • device (Optional[Union[device, str, int]], default: 'cpu' ) –

    user defined device. Defaults to None.

  • multi_gpu (bool, default: False ) –

    set to class attribute. Defaults to False.

Source code in SaigeToolkit/learning/device.py 
44
45
46
47
48
49
50
51
52
def __init__(self, device: DeviceType = "cpu", multi_gpu: bool = False) -> None:
    """initializing DeviceManager

    Args:
        device (Optional[Union[torch.device, str, int]], optional): user defined device. Defaults to None.
        multi_gpu (bool, optional): set to class attribute. Defaults to False.
    """
    self.set_gpu(device)
    self.multi_gpu = multi_gpu
set_gpu 
set_gpu(device: DeviceType = 'cpu') -> None

If user gives device string, use the defined device.

Parameters:

  • device (Optional[Union[device, str, int]], default: 'cpu' ) –

    user defined device. Defaults to None.

Source code in SaigeToolkit/learning/device.py 
54
55
56
57
58
59
60
def set_gpu(self, device: DeviceType = "cpu") -> None:
    """If user gives device string, use the defined device.

    Args:
        device (Optional[Union[torch.device, str, int]], optional): user defined device. Defaults to None.
    """
    self.device = torch.device(device)
module_to_device 
module_to_device(module: object) -> List[Optional[Module]]

converting torch modules to device

Parameters:

  • module (object) –

    task specific modules # XXX: isinstance of BaseModule?

Returns:

  • List[Optional[Module]] –

    List[torch.nn.Module]: network module list which needs to be reset after iteration step.

Source code in SaigeToolkit/learning/device.py 
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
def module_to_device(self, module: object) -> List[Optional[torch.nn.Module]]:
    """converting torch modules to device

    Args:
        module (object): task specific modules # XXX: isinstance of BaseModule?

    Returns:
        List[torch.nn.Module]: network module list which needs to be reset after iteration step.
    """
    reset_list = []

    # Setup Network
    for name in [attr for attr in list(dir(module)) if "network" in attr]:
        try:
            named_module = getattr(module, name).to(self.device)
            if hasattr(named_module, "reset"):
                reset_list.append(named_module)
            # Check if Using Multi-GPU
            if self.multi_gpu:
                named_module = AttributeDataParallel(named_module, output_device=self.device)
            setattr(module, name, named_module)
        except AttributeError:
            pass
        except Exception as e:
            print(f"uncaught error <{e}> occured: {name}")

    # Setup Sub-Module
    for name in [attr for attr in list(dir(module)) if "module" in attr]:
        sub_reset_list = self.module_to_device(getattr(module, name))
        reset_list = [*reset_list, *sub_reset_list]

    return reset_list
data_to_device 
data_to_device(*dummy: list, **data: dict) -> dict

convetring tensor-type data to device

Parameters:

  • data (dict, default: {} ) –

    data with tensors and also non-tensors.

Raises:

  • AssertionError –

    input data should be dict type.

Returns:

  • dict ( dict ) –

    data dict with tensors converted to device

Source code in SaigeToolkit/learning/device.py 
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
def data_to_device(self, *dummy: list, **data: dict) -> dict:
    """convetring tensor-type data to device

    Args:
        data (dict): data with tensors and also non-tensors.

    Raises:
        AssertionError: input data should be dict type.

    Returns:
        dict: data dict with tensors converted to device
    """

    if dummy:
        raise AssertionError(f"Non dictionary input is not allowed: {type(dummy)}")

    for key, value in data.items():
        if isinstance(value, list):
            value = [v.to(self.device) if torch.is_tensor(v) else v for v in value]
        else:
            value = value.to(self.device) if torch.is_tensor(value) else value

        data.update({key: value})

    return data

cuda_empty_cache 

cuda_empty_cache(device: DeviceType) -> None

CUDA device의 torch cache를 비웁니다 Multi-GPU 환경에서 0번이 아닌 device에 대해 empty_cache 호출 시 0번 device에 메모리 올리는 이슈를 해결

Source code in SaigeToolkit/learning/device.py 
132
133
134
135
136
137
138
def cuda_empty_cache(device: DeviceType) -> None:
    """CUDA device의 torch cache를 비웁니다
    Multi-GPU 환경에서 0번이 아닌 device에 대해 empty_cache 호출 시 0번 device에 메모리 올리는 이슈를 해결
    """
    if torch.device(device).type == "cuda":
        with torch.cuda.device(device):
            torch.cuda.empty_cache()

self_device_context 

self_device_context(method)

method에 self.device context 적용

Source code in SaigeToolkit/learning/device.py 
141
142
143
144
145
146
147
148
149
150
151
152
def self_device_context(method):
    """method에 self.device context 적용"""

    @wraps(method)
    def decorator(self, *args, **kwargs):
        if torch.device(self.device).type == "cuda":
            with torch.cuda.device(self.device):
                return method(self, *args, **kwargs)
        else:
            return method(self, *args, **kwargs)

    return decorator

apply_self_device_context 

apply_self_device_context()

class의 모든 method에 self.device context 적용 (staticmethod, classmethod 및 기본으로 정의된 method 제외)

Note: 모든 메소드에 적용하기 때문에 퍼포먼스 이슈가 발생할 수 있습니다

Usage 
@apply_self_device_context()
class InferenceHandler:
    ...
Source code in SaigeToolkit/learning/device.py 
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
def apply_self_device_context():
    """class의 모든 method에 self.device context 적용
    (staticmethod, classmethod 및 기본으로 정의된 method 제외)

    Note: 모든 메소드에 적용하기 때문에 퍼포먼스 이슈가 발생할 수 있습니다

    Usage:
        ```python

        @apply_self_device_context()
        class InferenceHandler:
            ...

        ```
    """

    def decorator_to_class(cls):
        for attr_name, attr_value in vars(cls).items():
            to_apply = (
                callable(attr_value)
                and not isinstance(attr_value, (staticmethod, classmethod))
                and hasattr(cls, attr_name)
                and getattr(cls, attr_name).__class__ == attr_value.__class__
            )
            if to_apply:
                setattr(cls, attr_name, self_device_context(attr_value))
        return cls

    return decorator_to_class

meter

Meter, updates and stores loss values and report average value.

Meter 

Meter()

Computes and stores the average and current losses by keys

Attributes:

  • meters (dict) –

    stored loss information by keys

Source code in SaigeToolkit/learning/meter.py 
13
14
def __init__(self) -> None:
    self.meters: Dict[str, AverageMeter] = {}
update 
update(loss: Union[Dict[str, float], List[float], float]) -> None

update result loss from network

Parameters:

  • loss (Union[Dict[str, float], List[float], float]) –

    loss to be stored. can be three types of data.

Source code in SaigeToolkit/learning/meter.py 
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
def update(self, loss: Union[Dict[str, float], List[float], float]) -> None:
    """update result loss from network

    Args:
        loss (Union[Dict[str, float], List[float], float]):
            loss to be stored. can be three types of data.
    """

    if isinstance(loss, dict):
        keys, loss = list(loss.keys()), list(loss.values())
    elif isinstance(loss, list):
        keys = ["loss" + str(i) for i in range(len(loss))]
    else:
        keys = ["loss"]
        loss = [loss]

    for key, l in zip(keys, loss):
        if key not in self.meters.keys():
            self.meters[key] = AverageMeter()
        self.meters[key].update(l)

AverageMeter 

AverageMeter()

Computes and stores the average and current value Attributes: val (float): last input loss value avg (float): average loss value sum (float): summed loss value min (float): min loss value max (float): max loss value count (int): total number of loss inputs

Source code in SaigeToolkit/learning/meter.py 
53
54
def __init__(self) -> None:
    self.reset()
update 
update(val: float, n: int = 1) -> None

update single loss value

Parameters:

  • val (float) –

    current loss value

  • n (int, default: 1 ) –

    current number of loss inputs. Defaults to 1.

Source code in SaigeToolkit/learning/meter.py 
64
65
66
67
68
69
70
71
72
73
74
75
76
def update(self, val: float, n: int = 1) -> None:
    """update single loss value

    Args:
        val (float): current loss value
        n (int, optional): current number of loss inputs. Defaults to 1.
    """
    self.val = val
    self.sum += val * n
    self.count += n
    self.avg = self.sum / self.count
    self.min = min(val, self.min)
    self.max = max(val, self.max)

get_meter 

get_meter() -> Tuple[Meter, Meter]

get loss/score average meter for training and validation

Returns:

  • Tuple[Meter, Meter] –

    Tuple[Meter, Meter]: training/validation meters

Source code in SaigeToolkit/learning/meter.py 
79
80
81
82
83
84
85
86
87
88
89
def get_meter() -> Tuple[Meter, Meter]:
    """get loss/score average meter for training and validation

    Returns:
        Tuple[Meter, Meter]: training/validation meters
    """

    train_meter = Meter()
    val_meter = Meter()

    return train_meter, val_meter

optimizer

building torch optimizers with simple configs

build_optimizer 

build_optimizer(model_params: Iterator[Parameter], _target_: str = 'SGD', **params) -> Optimizer

build optimizer object

Parameters:

  • model_params (Iterator[Parameter]) –

    parameters of model to be trained

  • _target_ (str, default: 'SGD' ) –

    optimizer name. Defaults to "SGD".

Raises:

  • NotImplementedError –

    description

Returns:

  • Optimizer ( Optimizer ) –

    optimizer object

Source code in SaigeToolkit/learning/optimizer.py 
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
def build_optimizer(model_params: Iterator[Parameter], _target_: str = "SGD", **params) -> Optimizer:
    """build optimizer object

    Args:
        model_params (Iterator[Parameter]): parameters of model to be trained
        _target_ (str, optional): optimizer name. Defaults to "SGD".

    Raises:
        NotImplementedError: _description_

    Returns:
        Optimizer: optimizer object
    """
    if _target_ not in _types:
        raise NotImplementedError(f"OPTIMIZER {_target_} not implemented")
    logger.info(f"[{'OPTIMIZER'.center(9)}] {_target_} [params] {params}")
    return _types[_target_](model_params, **params)

scheduler

torch learning rate schdulers and Few custom schedulers

FixedLR 

FixedLR(optimizer: Optimizer, last_epoch: int = -1)

Bases: _LRScheduler

constant learning rate

initializing FixedLR

Parameters:

  • optimizer (Optimizer) –

    optimizer

  • last_epoch (int, default: -1 ) –

    index of last epoch. Defaults to -1.

Source code in SaigeToolkit/learning/scheduler.py 
51
52
53
54
55
56
57
58
def __init__(self, optimizer: Optimizer, last_epoch: int = -1) -> None:
    """initializing FixedLR

    Args:
        optimizer (Optimizer): optimizer
        last_epoch (int, optional): index of last epoch. Defaults to -1.
    """
    super(FixedLR, self).__init__(optimizer, last_epoch)

PolynomialLR 

PolynomialLR(optimizer: Optimizer, max_iter: int, decay_iter: int = 1, gamma: float = 0.9, last_epoch: int = -1)

Bases: _LRScheduler

polynomial learning rate scheduler

Attributes:

  • decay_iter (int) –

    decaying iteration number

  • max_iter (int) –

    max iteration number for decaying

  • gamma (float) –

    learning rate decay rate (exponents)

initializing PolynomialLR

Parameters:

  • optimizer (Optimizer) –

    optimizer

  • max_iter (int) –

    max iteration number for decaying

  • decay_iter (int, default: 1 ) –

    decaying iteration number. Defaults to 1.

  • gamma (float, default: 0.9 ) –

    learning rate decay rate (exponents). Defaults to 0.9.

  • last_epoch (int, default: -1 ) –

    index of last epoch. Defaults to -1.

Source code in SaigeToolkit/learning/scheduler.py 
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
def __init__(
    self,
    optimizer: Optimizer,
    max_iter: int,
    decay_iter: int = 1,
    gamma: float = 0.9,
    last_epoch: int = -1,
) -> None:
    """initializing PolynomialLR

    Args:
        optimizer (Optimizer): optimizer
        max_iter (int): max iteration number for decaying
        decay_iter (int, optional): decaying iteration number. Defaults to 1.
        gamma (float, optional): learning rate decay rate (exponents). Defaults to 0.9.
        last_epoch (int, optional): index of last epoch. Defaults to -1.
    """
    self.decay_iter = decay_iter
    self.max_iter = max_iter
    self.gamma = gamma
    super(PolynomialLR, self).__init__(optimizer, last_epoch)

WarmUpLR 

WarmUpLR(optimizer: Optimizer, scheduler: dict, mode: str = 'linear', warmup_iters: int = 100, gamma: float = 0.2)

Bases: _LRScheduler

Wrapper for learning rate scheduler with warm-up stage

Attributes:

  • mode (str) –

    base schduler mode after warm-up stage

  • scheduler (_LRScheduler) –

    schduler for cold_lrs (warm-up stage)

  • warmup_iters (int) –

    number of iterations for warm-up stage

  • gamma (float) –

    learning rate decay rate

Parameters:

  • scheduler (dict) –

    schduler dict for cold_lrs (warm-up stage)

  • mode (str, default: 'linear' ) –

    base schduler mode after warm-up stage. Defaults to "linear".

  • warmup_iters (int, default: 100 ) –

    number of iterations for warm-up stage. Defaults to 100.

  • gamma (float, default: 0.2 ) –

    learning rate decay ratev. Defaults to 0.2.

Source code in SaigeToolkit/learning/scheduler.py 
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
def __init__(
    self,
    optimizer: Optimizer,
    scheduler: dict,
    mode: str = "linear",
    warmup_iters: int = 100,
    gamma: float = 0.2,
) -> None:
    """
    Args:
        scheduler (dict): schduler dict for cold_lrs (warm-up stage)
        mode (str, optional): base schduler mode after warm-up stage. Defaults to "linear".
        warmup_iters (int, optional): number of iterations for warm-up stage. Defaults to 100.
        gamma (float, optional): learning rate decay ratev. Defaults to 0.2.
    """
    self._warmup_strategy = mode
    if self._warmup_strategy == "cos":
        self._warmup_func = self._warmup_cos
    elif self._warmup_strategy == "linear":
        self._warmup_func = self._warmup_linear
    elif self._warmup_strategy == "const":
        self._warmup_func = self._warmup_const
    else:
        raise NotImplementedError(f"Warmup type {self._warmup_strategy} not implemented.")

    self.gamma = gamma

    self._scheduler = build_scheduler(optimizer=optimizer, **scheduler)
    self._init_lr = self._scheduler.optimizer.param_groups[0]["lr"] * self.gamma
    self._warmup_iters = warmup_iters
    self._step_count = 0
    self._format_param()
state_dict 
state_dict()

Returns the state of the scheduler as a :class:dict. It contains an entry for every variable in self.dict which is not the optimizer.

Source code in SaigeToolkit/learning/scheduler.py 
156
157
158
159
160
161
162
163
164
165
166
167
def state_dict(self):
    """Returns the state of the scheduler as a :class:`dict`.
    It contains an entry for every variable in self.__dict__ which
    is not the optimizer.
    """
    wrapper_state_dict = {
        key: value for key, value in self.__dict__.items() if key not in ["optimizer", "_scheduler"]
    }
    wrapped_state_dict = {
        key: value for key, value in self._scheduler.__dict__.items() if key != "optimizer"
    }
    return {"wrapped": wrapped_state_dict, "wrapper": wrapper_state_dict}
load_state_dict 
load_state_dict(state_dict: dict)

Loads the schedulers state.

Parameters:

  • state_dict (dict) –

    scheduler state. Should be an object returned from a call to :meth:state_dict.

Source code in SaigeToolkit/learning/scheduler.py 
169
170
171
172
173
174
175
176
177
def load_state_dict(self, state_dict: dict):
    """Loads the schedulers state.

    Args:
        state_dict (dict): scheduler state. Should be an object returned
            from a call to :meth:`state_dict`.
    """
    self.__dict__.update(state_dict["wrapper"])
    self._scheduler.__dict__.update(state_dict["wrapped"])

CosineAnnealingWarmUpRestarts 

CosineAnnealingWarmUpRestarts(optimizer: Optimizer, T_0: int, T_mult: int = 1, eta_max: float = 0.1, T_up: int = 0, gamma: float = 1.0, last_epoch: int = -1)

Bases: _LRScheduler

Cosine Anneeling scheduler with Warmup restarts (SGDR).

Modified from https://github.com/pytorch/pytorch/blob/v1.1.0/torch/optim/lr_scheduler.py#L655, implementing initial warmup stage.

Usage:

optimizer: ... target: sgd ... lr: 0.0 # optimizer lr should be zero or very small value!!! ... momentum: 0.9 ... weight_decay: 0.0001 ... scheduler: ... target: CosineAnnealingWarmUpRestarts ... T_0: 50000 ... T_mult: 1 ... eta_max: 0.005 ... T_up: 500 ... gamma: 0.5

Parameters:

  • optimizer (Optimizer) –

    Pytorch optimizer instance.

  • T_0 (int) –

    Initial annealing cycle length.

  • T_mult (int, default: 1 ) –

    Cycle multiplication scale after the first cycle. Defaults to 1.

  • eta_max (float, default: 0.1 ) –

    Max learning rate. Defaults to 0.1.

  • T_up (int, default: 0 ) –

    Warmup step size. Defaults to 0.

  • gamma (float, default: 1.0 ) –

    eta_max multiplication scale after the first cycle. Defaults to 1..

  • last_epoch (int, default: -1 ) –

    Last epoch of the scheduler. Defaults to -1.

Raises:

  • ValueError –

    Expected positive integer T_0

  • ValueError –

    Expected integer T_mult >= 1

  • ValueError –

    Expected positive integer T_up

Source code in SaigeToolkit/learning/scheduler.py 
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
def __init__(
    self,
    optimizer: Optimizer,
    T_0: int,
    T_mult: int = 1,
    eta_max: float = 0.1,
    T_up: int = 0,
    gamma: float = 1.0,
    last_epoch: int = -1,
):
    """
    Args:
        optimizer (Optimizer): Pytorch optimizer instance.
        T_0 (int): Initial annealing cycle length.
        T_mult (int, optional): Cycle multiplication scale after the first cycle. Defaults to 1.
        eta_max (float, optional): Max learning rate. Defaults to 0.1.
        T_up (int, optional): Warmup step size. Defaults to 0.
        gamma (float, optional): eta_max multiplication scale after the first cycle. Defaults to 1..
        last_epoch (int, optional): Last epoch of the scheduler. Defaults to -1.

    Raises:
        ValueError: Expected positive integer T_0
        ValueError: Expected integer T_mult >= 1
        ValueError: Expected positive integer T_up
    """
    if T_0 <= 0 or not isinstance(T_0, int):
        raise ValueError(f"Expected positive integer T_0, but got {T_0}")
    if T_mult < 1 or not isinstance(T_mult, int):
        raise ValueError(f"Expected integer T_mult >= 1, but got {T_mult}")
    if T_up < 0 or not isinstance(T_up, int):
        raise ValueError(f"Expected positive integer T_up, but got {T_up}")
    self.T_0 = T_0
    self.T_mult = T_mult
    self.base_eta_max = eta_max
    self.eta_max = eta_max
    self.T_up = T_up
    self.T_i = T_0
    self.gamma = gamma
    self.cycle = 0
    self.T_cur = last_epoch
    super(CosineAnnealingWarmUpRestarts, self).__init__(optimizer, last_epoch)

ProportionalMultiStepLR 

ProportionalMultiStepLR(optimizer, iteration: int, milestones: Sequence[float], **kwargs)

Bases: MultiStepLR

전체 iteration에 대한 비율로 milestone을 설정하는 MultiStepLR 스케줄러

Source code in SaigeToolkit/learning/scheduler.py 
329
330
331
def __init__(self, optimizer, iteration: int, milestones: Sequence[float], **kwargs) -> None:
    milestones_ = [int(iteration * proportion) for proportion in sorted(milestones)]
    super().__init__(optimizer=optimizer, milestones=milestones_, **kwargs)

SaigeVision1_5080_LR 

SaigeVision1_5080_LR(optimizer, iteration: int, **kwargs)

Bases: ProportionalMultiStepLR

SaigeVision1 제품에 적용된 스케줄러. 전체 iteration의 50%, 80% 지점에서 learning rate을 0.5배씩 줄입니다.

Source code in SaigeToolkit/learning/scheduler.py 
337
338
def __init__(self, optimizer, iteration: int, **kwargs) -> None:
    super().__init__(optimizer, iteration=iteration, milestones=[0.5, 0.8], gamma=0.5, **kwargs)

build_scheduler 

build_scheduler(optimizer: Optimizer, _target_: str = 'FixedLR', **params) -> _LRScheduler

builds leraning rate scheduler

Parameters:

  • optimizer (Optimizer) –

    optimizer object

  • _target_ (str, default: 'FixedLR' ) –

    learning rate scheduler configuration dict. Defaults to "FixedLR".

Raises:

  • NotImplementedError –

    description

Returns:

  • _LRScheduler ( _LRScheduler ) –

    learning rate scheduler object

Source code in SaigeToolkit/learning/scheduler.py 
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
def build_scheduler(optimizer: Optimizer, _target_: str = "FixedLR", **params) -> _LRScheduler:
    """builds leraning rate scheduler

    Args:
        optimizer (Optimizer): optimizer object
        _target_ (str, optional): learning rate scheduler configuration dict. Defaults to "FixedLR".

    Raises:
        NotImplementedError: _description_

    Returns:
        _LRScheduler: learning rate scheduler object
    """
    if _target_ not in _types:
        raise NotImplementedError(f"SCHEDULER {_target_} not implemented")
    logger.info(f"[{'SCHEDULER'.center(9)}] {_target_} [params] {params}")
    return _types[_target_](optimizer, **params)

trainer

BaseTrainer

Bases: ABC

Saige Vision2 Engine 학습 API의 베이스 인터페이스 입니다. 기본적인 규약만 정해져있으며 각 태스크에 맞게 abstractmethod들을 구현하고, error_handler를 씌워서 노출시키면 됩니다.

About Init

init 메소드 작성 시 util.reproducibility.store_config 데코레이터를 활용하면 _config를 쉽게 저장할 수 있습니다.

Example: class Trainer(BaseTrainer): @store_config(attr="_config") # 인스턴스 생성 시 self._config 변수에 생성 파라미터들 저장됨 def init(self, param1, param2): ...

About Checkpoint

체크포인트를 저장/로드 하는 인터페이스는 save_checkpoint, load_checkpoint로 이미 구현되어 있으며, 태스크에 맞게 state_dict, load_state_dict를 구현하면 해당 함수를 이용해 상태를 저장/로드 하는 방식입니다.