| import os |
| import urllib |
| import torch |
| from torch.utils import model_zoo |
|
|
|
|
| class CheckpointIO(object): |
| ''' CheckpointIO class. |
| |
| It handles saving and loading checkpoints. |
| |
| Args: |
| checkpoint_dir (str): path where checkpoints are saved |
| ''' |
| def __init__(self, checkpoint_dir='./chkpts', initialize_from=None, |
| initialization_file_name='model_best.pt', **kwargs): |
| self.module_dict = kwargs |
| self.checkpoint_dir = checkpoint_dir |
| self.initialize_from = initialize_from |
| self.initialization_file_name = initialization_file_name |
| if not os.path.exists(checkpoint_dir): |
| os.makedirs(checkpoint_dir) |
|
|
| def register_modules(self, **kwargs): |
| ''' Registers modules in current module dictionary. |
| ''' |
| self.module_dict.update(kwargs) |
|
|
| def save(self, filename, **kwargs): |
| ''' Saves the current module dictionary. |
| |
| Args: |
| filename (str): name of output file |
| ''' |
| if not os.path.isabs(filename): |
| filename = os.path.join(self.checkpoint_dir, filename) |
|
|
| outdict = kwargs |
| for k, v in self.module_dict.items(): |
| outdict[k] = v.state_dict() |
| torch.save(outdict, filename) |
|
|
| def load(self, filename): |
| '''Loads a module dictionary from local file or url. |
| |
| Args: |
| filename (str): name of saved module dictionary |
| ''' |
| if is_url(filename): |
| return self.load_url(filename) |
| else: |
| return self.load_file(filename) |
|
|
| def load_file(self, filename): |
| '''Loads a module dictionary from file. |
| |
| Args: |
| filename (str): name of saved module dictionary |
| ''' |
|
|
| if not os.path.isabs(filename): |
| filename = os.path.join(self.checkpoint_dir, filename) |
|
|
| if os.path.exists(filename): |
| print(filename) |
| print('=> Loading checkpoint from local file...') |
| state_dict = torch.load(filename) |
| scalars = self.parse_state_dict(state_dict) |
| return scalars |
| else: |
| if self.initialize_from is not None: |
| self.initialize_weights() |
| raise FileExistsError |
|
|
| def load_url(self, url): |
| '''Load a module dictionary from url. |
| |
| Args: |
| url (str): url to saved model |
| ''' |
| print(url) |
| print('=> Loading checkpoint from url...') |
| state_dict = model_zoo.load_url(url, progress=True) |
| scalars = self.parse_state_dict(state_dict) |
| return scalars |
|
|
| def parse_state_dict(self, state_dict): |
| '''Parse state_dict of model and return scalars. |
| |
| Args: |
| state_dict (dict): State dict of model |
| ''' |
|
|
| for k, v in self.module_dict.items(): |
| if k in state_dict: |
| v.load_state_dict(state_dict[k]) |
| else: |
| print('Warning: Could not find %s in checkpoint!' % k) |
| scalars = {k: v for k, v in state_dict.items() |
| if k not in self.module_dict} |
| return scalars |
|
|
| def initialize_weights(self): |
| ''' Initializes the model weights from another model file. |
| ''' |
|
|
| print('Intializing weights from model %s' % self.initialize_from) |
| filename_in = os.path.join( |
| self.initialize_from, self.initialization_file_name) |
|
|
| model_state_dict = self.module_dict.get('model').state_dict() |
| model_dict = self.module_dict.get('model').state_dict() |
| model_keys = set([k for (k, v) in model_dict.items()]) |
|
|
| init_model_dict = torch.load(filename_in)['model'] |
| init_model_k = set([k for (k, v) in init_model_dict.items()]) |
|
|
| for k in model_keys: |
| if ((k in init_model_k) and (model_state_dict[k].shape == |
| init_model_dict[k].shape)): |
| model_state_dict[k] = init_model_dict[k] |
| self.module_dict.get('model').load_state_dict(model_state_dict) |
|
|
|
|
| def is_url(url): |
| ''' Checks if input is url.''' |
| scheme = urllib.parse.urlparse(url).scheme |
| return scheme in ('http', 'https') |
|
|
