10 examples of 'torch save model' in Python

492
def save_model(self):
493
    torch.save(self.G.state_dict(), self.save_dir + "/G.pt")
494
    torch.save(self.E.state_dict(), self.save_dir + "/E.pt")
495
    torch.save(self.D.state_dict(), self.save_dir + "/D.pt")

103
def saveModel(state, epoch, loss_epoch, valid_epoch, is_best, episode_idx):
104
    torch.save({
105
        "epoch": epoch,
106
        "episodes": episode_idx + 1,
107
        "state_dict": state,
108
        "epoch_avg_loss": round(loss_epoch, 10),
109
        "epoch_avg_valid": round(valid_epoch, 10)
110
    }, MODEL_PATH)
111
    if is_best:
112
        shutil.copyfile(MODEL_PATH, MODEL_PATH_BEST)

101
def saveModel(state, epoch, loss_epoch, diff_epoch, is_best, episode_idx):
102
    torch.save({
103
        "epoch": epoch,
104
        "episodes": episode_idx + 1,
105
        "state_dict": state,
106
        "epoch_avg_loss": np.mean(loss_epoch),
107
        "epoch_avg_diff": np.mean(diff_epoch)
108
    }, MODEL_PATH)
109
    if is_best:
110
        shutil.copyfile(MODEL_PATH, MODEL_PATH_BEST)

26
def save_model(model, name, epoch, folder_name):
27
    print("Saving Model")
28
    torch.save(model.state_dict(),
29
               (folder_name + "trained_{}.pth").format(epoch))
30
    print("Done saving Model")

79
def save_model(model, optim, epoch, path):
80
    torch.save({
81
        'epoch': epoch + 1,
82
        'state_dict': model.state_dict(),
83
        'optimizer': optim.state_dict()}, path)

53
def save_model(net, model_path):
54
    model_dir = os.path.dirname(model_path)
55
    if not os.path.exists(model_dir):
56
       os.makedirs(model_dir)
57
    torch.save(net.state_dict(), model_path)

29
def save_checkpoint(now_epoch, net, optimizer, lr_scheduler, file_name):
30
    checkpoint = {'epoch': now_epoch,
31
                  'state_dict': net.state_dict(),
32
                  'optimizer_state_dict': optimizer.state_dict(),
33
                  'lr_scheduler_state_dict':lr_scheduler.state_dict()}
34
    if os.path.exists(file_name):
35
        print('Overwriting {}'.format(file_name))
36
    torch.save(checkpoint, file_name)

251
def save_model(self):
252
253
    path = self.output_dir/'model_out'
254
    path.mkdir(exist_ok=True)
255
256
    torch.cuda.empty_cache()
257
    # Save a trained model
258
    model_to_save = self.model.module if hasattr(self.model, 'module') else self.model  # Only save the model it-self
259
    model_to_save.save_pretrained(path)
260
261
    # save the tokenizer
262
    self.data.tokenizer.save_pretrained(path)

78
def save_model(self):
79
    torch.save(self.net, self.file_path + "unet_model.pkl")

20
def save(self, path, epoch):
21
    # must be rewritten if self is not nn.Module
22
    f = open(os.path.join(path, "%s.txt" % self.__name__), "w")
23
    f.write(str(self))
24
    f.close()
25
    torch.save(
26
        self.state_dict(), os.path.join(path, "%s_%s.pth" % (self.__name__, epoch))
27
    )