def load_model(self, **kwargs) -> nn.Module:
args = parser.parse_args()
# Directory path of the model
dirpathmodel = pf. \
generate_savefile_dirpath(type_="model",
graph=self.env_knl.ntw_name,
nlayers=self.nlayers,
nhid=self.nhid,
bptt=self.bptt,
nagts=self.env_knl.nagts,
model_type=self.model_type,
model_variant=self.model_variant,
suffix=self.model_variant_2,
datasrc=self.datasrc,
log_rep_dir=args.dirpath_models)
# Path of the model's latest version
# model_path = misc.get_latest_pytorch_model(dirpathmodel)
model_path = pf. \
entire_model_path(misc.get_latest_pytorch_model(dirpathmodel))
with open(model_path, "rb") as s:
if self.gpu:
# Loading on GPU if trained with CUDA
model = torch.load(s)
else:
# Loading on CPU if trained with CUDA
model = torch.load(s,
map_location=lambda storage, loc: storage)
# TDP
print("Path of the loaded model: {}".format(model_path))
return model
def __init__(self,
id_: int,
original_id: str,
env_knl: EnvironmentKnowledge,
connection: Connection,
agts_addrs: list,
datasrc: str = None,
model_type: str = "Mean",
model_variant: str = "Standard",
variant: str = '',
depth: float = 3.0,
interaction: bool = True):
r"""
Args:
id_ (int):
original_id (str):
env_knl (EnvironmentKnowledge):
connection (Connection):
agts_addrs (list):
datasrc (str):
model_type (str): The type of the model used to make predictions
model_variant (str): The variant of the model used to make
predictions
variant (str):
depth (float):
interaction (bool):
"""
HPAgent.__init__(self,
id_=id_,
original_id=original_id,
env_knl=env_knl,
connection=connection,
agts_addrs=agts_addrs,
variant=variant,
depth=depth,
interaction=interaction)
if datasrc is None:
args = parser.parse_args()
datasrc = args.datasrc
StatModelAgent.__init__(self,
id_=id_,
original_id=original_id,
env_knl=env_knl,
connection=connection,
agts_addrs=agts_addrs,
model_type=model_type,
model_variant=model_variant,
variant=variant,
depth=depth,
interaction=interaction,
datasrc=datasrc)
# Nodes' mean idlenesses:
self.idls_means = self.load_idlenesses_means()
def __init__(self,
id_: int,
original_id: str,
env_knl: EnvironmentKnowledge,
connection: Connection,
agts_addrs: list,
datasrc: str = None,
variant: str = '',
gpu: bool = False,
depth: float = 3.0,
model_type: str = "Linear",
model_variant: str = "IdentityWeights",
interaction: bool = True):
r"""
Args:
id_ (int):
original_id (str):
env_knl (EnvironmentKnowledge):
connection (Connection):
agts_addrs (list):
datasrc (str):
variant (str):
gpu (bool):
depth (float):
model_type (str):
model_variant (str):
interaction (bool):
"""
HPAgent.__init__(self,
id_=id_,
original_id=original_id,
env_knl=env_knl,
connection=connection,
agts_addrs=agts_addrs,
variant=variant,
depth=depth,
interaction=interaction)
if datasrc is None:
args = parser.parse_args()
datasrc = args.datasrc
MAPTrainerModelAgent.__init__(self,
id_=id_,
original_id=original_id,
env_knl=env_knl,
connection=connection,
agts_addrs=agts_addrs,
variant=variant,
depth=depth,
gpu=gpu,
model_type=model_type,
model_variant=model_variant,
interaction=interaction,
datasrc=datasrc)
def __init__(self,
id_: int,
original_id: str,
env_knl: EnvironmentKnowledge,
connection: Connection,
agts_addrs: list,
variant: str = '',
gpu: bool = True,
depth: float = 3.0,
interaction: bool = True,
datasrc: str = None,
**kwargs):
r"""
Args:
id_ (int):
original_id (str):
env_knl (EnvironmentKnowledge):
connection (Connection):
agts_addrs (list):
variant (str):
gpu (bool):
depth (float):
interaction (bool):
datasrc (str):
**kwargs:
"""
self.nlayers = self.load_nlayers(variant)
self.nhid = self.load_nhid(variant)
self.bptt = self.load_bptt(variant)
# self.model_variant_2 = "Adagrad-pre"
self.model_variant_2 = '' # TODO: passing this attribute as
# argument of the constructor
if datasrc is None:
args = parser.parse_args()
datasrc = args.datasrc
super().__init__(id_=id_,
original_id=original_id,
env_knl=env_knl,
connection=connection,
agts_addrs=agts_addrs,
variant=variant,
depth=depth,
gpu=gpu,
model_type="MAPLSTM",
model_variant="MAPLSTM",
datasrc=datasrc,
interaction=interaction)
self.hidden = self.model.init_hidden(1)
def load_idlenesses_means(self) -> list:
args = parser.parse_args()
# Current configuration's means' file path
config_means_fp = pf.means_path(datasrc=self.datasrc,
g=self.env_knl.ntw_name,
n=self.env_knl.nagts,
mean_dirpath=args.meanspath)
with open(config_means_fp) as s:
return json.load(s)
def __init__(self,
id_: int,
original_id: str,
env_knl: EnvironmentKnowledge,
connection: Connection,
agts_addrs: list,
variant: str = '',
gpu: bool = False,
depth: float = 3.0,
interaction: bool = True,
datasrc: str = None):
r"""
Args:
id_ (int):
original_id (str):
env_knl (EnvironmentKnowledge):
connection (Connection):
agts_addrs (list):
variant (str):
gpu (bool):
depth (float):
interaction (bool):
datasrc (str):
"""
if datasrc is None:
args = parser.parse_args()
datasrc = args.datasrc
super().__init__(id_=id_,
original_id=original_id,
env_knl=env_knl,
connection=connection,
agts_addrs=agts_addrs,
variant=variant,
depth=depth,
gpu=gpu,
interaction=interaction,
datasrc=datasrc)
width=100,
sep='\n',
refs_format='{'
'num}\t{type} {obj}',
bytes_format='{num}\t {obj}',
types_format='{num}\t {obj}',
verbose_types=None,
verbose_file_name="logs/mem_top.txt")), '\n')
print("{}: ----------------------------------\n" \
.format(misc.timestamp(), misc.get_memusage()))
# Executed only if run as a script
if __name__ == '__main__':
args = parser.parse_args()
# main(dirpath_execs=Paths.LOCALEXECS, duration=10, exec_id=1,
# strategy="rhple")
main(graph=args.map,
strategy=args.strategy,
variant=args.variant,
datasrc=args.datasrc,
nagts=args.nagts,
duration=args.duration,
soc_name=args.society,
exec_id=args.execid,
dirpath_execs=args.dirpath_execs,
dirpath_logs=args.dirpath_logs,
depth=args.depth,
trace_agents=args.trace_agents,
