zoukankan      html  css  js  c++  java
  • tensorflow, pytorch,loss可视化画图模板代码(推荐)

    重要的几段代码摘抄如下:

    import matplotlib.pyplot as plt
    
    yy_train_loss = []
    yy_valid_loss = []
    yy_train_acc = []
    yy_valid_acc = []
    xx = []
    
    #def train 或 def fit:
        for epoch in range(epochs):
                xx.append(epoch)
                yy_train_loss.append(total_loss / len(loader_train))
                yy_train_acc.append( train_acc  )
        
        #valid:
        yy_valid_loss.append(total_loss / len(loader))
        yy_valid_acc.append(val_gini_score)
    
    #可视化并且保存
    #def plot_png():
    ax1 = plt.subplot(1, 2, 1) plt.sca(ax1) plt.plot(xx, yy_train_loss, "r", label="train_logloss") plt.plot(xx, yy_valid_loss, "b", label="valid_logloss") plt.legend() ax2 = plt.subplot(1, 2, 2) plt.sca(ax2) plt.plot(xx, yy_train_acc, "y", label="train_acc") plt.plot(xx, yy_valid_acc, "g", label="valid_norm_gini") plt.legend() plt.savefig("./loss.png") print("保存了loss.png") print("over!")

    给一个DeepFM.py完整文件

    # -*- coding: utf-8 -*-
    
    """
    A pytorch implementation of DeepFM for rates prediction problem.
    """
    import numpy as np
    import torch
    import torch.nn as nn
    import torch.nn.functional as F
    import matplotlib.pyplot as plt
    import os
    from metrics import gini_norm
    
    import sys
    import torch.optim as optim
    
    import time
    
    yy_train_loss = []
    yy_valid_loss = []
    yy_train_acc = []
    yy_valid_acc = []
    xx = []
    best_acc = 0
    best_gini_score = 0        # gini越大越好
    
    criterion = F.binary_cross_entropy_with_logits  #相当于logloss  ,这里自己修改,改成自定义的gini系数
    
    class DeepFM(nn.Module):
        """
        A DeepFM network with RMSE loss for rates prediction problem.
    
        There are two parts in the architecture of this network: fm part for low
        order interactions of features and deep part for higher order. In this 
        network, we use bachnorm and dropout technology for all hidden layers,
        and "Adam" method for optimazation.
    
        You may find more details in this paper:
        DeepFM: A Factorization-Machine based Neural Network for CTR Prediction,
        Huifeng Guo, Ruiming Tang, Yunming Yey, Zhenguo Li, Xiuqiang He.
        """
    
        def __init__(self, feature_sizes, embedding_size=8,
                     hidden_dims=[32, 32], num_classes=1, dropout=[0.5, 0.5], 
                     use_cuda=True, verbose=False):
            """
            Initialize a new network
    
            Inputs: 
            - feature_size: A list of integer giving the size of features for each field.
            - embedding_size: An integer giving size of feature embedding.
            - hidden_dims: A list of integer giving the size of each hidden layer.
            - num_classes: An integer giving the number of classes to predict. For example,
                        someone may rate 1,2,3,4 or 5 stars to a film.
            - batch_size: An integer giving size of instances used in each interation.
            - use_cuda: Bool, Using cuda or not
            - verbose: Bool
            """
            super().__init__()
            self.field_size = len(feature_sizes)
            self.feature_sizes = feature_sizes
            self.embedding_size = embedding_size
            self.hidden_dims = hidden_dims
            self.num_classes = num_classes
            self.dtype = torch.long
            self.bias = torch.nn.Parameter(torch.randn(1))
            """
                check if use cuda
            """
            if use_cuda and torch.cuda.is_available():
                self.device = torch.device('cuda')
            else:
                self.device = torch.device('cpu')
            """
                init fm part
            """
            self.fm_first_order_embeddings = nn.ModuleList(
                [nn.Embedding(feature_size, 1) for feature_size in self.feature_sizes])
            self.fm_second_order_embeddings = nn.ModuleList(
                [nn.Embedding(feature_size, self.embedding_size) for feature_size in self.feature_sizes])
            """
                init deep part
            """
            all_dims = [self.field_size * self.embedding_size] + 
                self.hidden_dims + [self.num_classes]  #形如[k,h1,h2,1] , hidden_dims是[32,32]
            for i in range(1, len(hidden_dims) + 1):
                setattr(self, 'linear_'+str(i),                 # 新方法,setattr设置object的属性时,属性不一定存在
                        nn.Linear(all_dims[i-1], all_dims[i]))
                # nn.init.kaiming_normal_(self.fc1.weight)
                setattr(self, 'batchNorm_' + str(i),
                        nn.BatchNorm1d(all_dims[i]))
                setattr(self, 'dropout_'+str(i),
                        nn.Dropout(dropout[i-1]))
    
        def forward(self, Xi, Xv):
            """
            Forward process of network. 
    
            Inputs:
            - Xi: A tensor of input's index, shape of (N, field_size, 1)  #注意!这里因为是一个batch,所以是三维的
            - Xv: A tensor of input's value, shape of (N, field_size)   # modified,原文写错了点,这里是二维
            """
            """
                fm part
            """
            # Xv[:, i]) 维度是(100,)
    
            # test code
            # for i,emb in enumerate(self.fm_first_order_embeddings):
            #     print("i:",i)
            #     print("emb:",emb)
            #     print("Xi.shape:",Xi.shape)
            #     print("Xi:",Xi)
            #     print("Xi[:,i,:]:", Xi[:,i,:])
    
            fm_first_order_emb_arr = [(torch.sum(emb(Xi[:, i, :]), 1).t() * Xv[:, i]).t() for i, emb in enumerate(self.fm_first_order_embeddings)]
            fm_first_order = torch.cat(fm_first_order_emb_arr, 1)  # 100*39
            fm_second_order_emb_arr = [(torch.sum(emb(Xi[:, i, :]), 1).t() * Xv[:, i]).t() for i, emb in enumerate(self.fm_second_order_embeddings)]
            # fm_second_order_emb_arr: [N*k, N*k, ...]
            fm_sum_second_order_emb = sum(fm_second_order_emb_arr)
            fm_sum_second_order_emb_square = fm_sum_second_order_emb * 
                fm_sum_second_order_emb  # (x+y)^2
            fm_second_order_emb_square = [
                item*item for item in fm_second_order_emb_arr]
            fm_second_order_emb_square_sum = sum(
                fm_second_order_emb_square)  # x^2+y^2
            fm_second_order = (fm_sum_second_order_emb_square -
                               fm_second_order_emb_square_sum) * 0.5
            """
                deep part
            """
            deep_emb = torch.cat(fm_second_order_emb_arr, 1)  #按照列方向进行拼接
            deep_out = deep_emb
            for i in range(1, len(self.hidden_dims) + 1):
                deep_out = getattr(self, 'linear_' + str(i))(deep_out)
                deep_out = getattr(self, 'batchNorm_' + str(i))(deep_out)
                deep_out = getattr(self, 'dropout_' + str(i))(deep_out)
            """
                sum
            """
            total_sum = torch.sum(fm_first_order, 1) + 
                        torch.sum(fm_second_order, 1) + torch.sum(deep_out, 1) + self.bias
            return total_sum
    
        def fit(self, loader_train, loader_val, optimizer, epochs=100, verbose=False, print_every=100):
            """
            Training a model and valid accuracy.
    
            Inputs:
            - loader_train: I
            - loader_val: .
            - optimizer: Abstraction of optimizer used in training process, e.g., "torch.optim.Adam()""torch.optim.SGD()".
            - epochs: Integer, number of epochs.
            - verbose: Bool, if print.
            - print_every: Integer, print after every number of iterations. 
            """
            """
                load input data
            """
            model = self.train().to(device=self.device)
    
    
            for epoch in range(epochs):
                #global s_time, e_time
                s_time = time.time()
                
                xx.append(epoch)
                train_num_correct = 0
                train_num_samples = 0
                total_loss = 0
                train_acc = 0
                all_gini_score = 0
    
                for t, (xi, xv, y) in enumerate(loader_train):
                    xi = xi.to(device=self.device, dtype=self.dtype)
                    xv = xv.to(device=self.device, dtype=torch.float)
                    y = y.to(device=self.device, dtype=torch.float)
                    
                    total = model(xi, xv)  # 回到forward函数 , 返回 100*1维
                    loss = criterion(total, y)  # y是label,整型 0或1
    
                    #preds_prob = F.sigmoid(total)
                    #gini_score = gini_norm(y, preds_prob)   # actual/pred
    
                    #gini_score = gini_norm(y.cuda().data.cpu().numpy(), preds_prob.cuda().data.cpu().numpy())
    
                    #all_gini_score += gini_score
                    # print("type(all_gini_score):",type(all_gini_score))
                    # print("all_gini_score/len(loader_train):",all_gini_score/len(loader_train))
    
                    preds = (F.sigmoid(total) > 0.5)  # 配合sigmoid使用
                    train_num_correct += (preds == y).sum()
                    train_num_samples += preds.size(0)  # 每次加上一个batch_size
                    total_loss += loss.item()
    
                    optimizer.zero_grad()
                    loss.backward()
                    optimizer.step()
    
                    train_acc = float(train_num_correct) / train_num_samples
                    #print('Got Train %d / %d correct (%.2f%%)' % (train_num_correct, train_num_samples, 100 * train_acc))
    
                    print('[ Epoch{}: {}/{} ] loss:{:.3f} acc:{:.3f} '.format(epoch + 1, t + 1, len(loader_train), loss.item(), train_acc *100), end='
    ')
    
                    # print('[ Epoch{}: {}/{} ] loss:{:.3f} gini_score:{:.4f} '.format(
                    #          epoch + 1, t + 1, len(loader_train), loss.item(), all_gini_score / (t+1)), end='
    ')
                e_time = time.time()
                print("epoch:{} cost time:{} minutes:".format(epoch, (e_time-s_time)/60 ))
                print('
    Train | Loss:{:.5f} acc: {:.3f}'.format(total_loss / len(loader_train), train_acc  ))
                yy_train_loss.append(total_loss / len(loader_train))
                yy_train_acc.append( train_acc  )
    
                #if verbose and t % print_every == 0:             #修改源代码,减少一个tab
               # if verbose:
                    #print('Iteration %d, loss = %.4f' % (t, loss.item()))
                self.check_accuracy(loader_val, model)
    
            #end of epoch loop
    
            ax1 = plt.subplot(1, 2, 1)
            plt.sca(ax1)
            plt.plot(xx, yy_train_loss, "r", label="train_logloss")
            plt.plot(xx, yy_valid_loss, "b", label="valid_logloss")
            plt.legend()
            ax2 = plt.subplot(1, 2, 2)
            plt.sca(ax2)
            plt.plot(xx, yy_train_acc, "y", label="train_acc")
            plt.plot(xx, yy_valid_acc, "g", label="valid_norm_gini")
            plt.legend()
    
            plt.savefig("./loss.png")
            print("保存了loss.png和model_save/best_ckpt.model")
            print("model.fit() over!")
        
        def check_accuracy(self, loader, model):
    #         if loader.dataset.train:
    #             print('Checking accuracy on validation set')
    #         else:
    #             print('Checking accuracy on test set')   
            num_correct = 0
            num_samples = 0
            model.eval()  # set model to evaluation mode
            with torch.no_grad():
                total_loss = 0
                all_gini_score = 0
                pred_gini = []
                actual = []
                for t,(xi, xv, y) in enumerate(loader):
                    xi = xi.to(device=self.device, dtype=self.dtype)  # move to device, e.g. GPU
                    xv = xv.to(device=self.device, dtype=torch.float)
                    y = y.to(device=self.device, dtype=torch.float)
    
                    total = model(xi, xv)
    
                    loss = criterion(total, y)
    
                    preds_prob = F.sigmoid(total)
                    #gini_score = gini_norm(y, preds_prob)  # actual/pred
                    # gini_score = gini_norm(y.cuda().data.cpu().numpy(), preds_prob.cuda().data.cpu().numpy())
                    #print("type(y.cuda().data.cpu().numpy()):",type(y.cuda().data.cpu().numpy()) )
                    actual = np.append(actual , y.cuda().data.cpu().numpy())
                    pred_gini = np.append(pred_gini , preds_prob.cuda().data.cpu().numpy())
                    
                    # all_gini_score += gini_score
    
    
                    total_loss += loss.item()
    
                    y = y.to(device=self.device, dtype=torch.bool)
                    preds = (F.sigmoid(total) > 0.5)  #配合sigmoid使用
                    num_correct += (preds == y).sum()
                    num_samples += preds.size(0)  #每次加上一个batch_size
                valid_acc = float(num_correct) / num_samples
                
                
                
                val_gini_score = gini_norm(actual, pred_gini)
                # exit(0)
    
               # print("valid norm gini:", val_gini_score)
    
                #print('Got Valid %d / %d correct (%.2f%%)' % (num_correct, num_samples, 100 * acc))
                print("Valid | Loss:{:.5f} norm_gini:{}".format(total_loss / len(loader), val_gini_score ))
    
                yy_valid_loss.append(total_loss / len(loader))
                yy_valid_acc.append(val_gini_score)
                if(not os.path.exists("model_save")):
                        os.mkdir("model_save")
                        
                torch.save(model, "model_save/final_ckpt.model") # best_ckpt.model 和test.ipynb文件保持一致才行
                
                global best_gini_score
                if val_gini_score  > best_gini_score:
    
                    # 如果validation的結果優於之前所有的結果,就把當下的模型存下來以備之後做預測時使用
                    best_gini_score = val_gini_score
                    if(not os.path.exists("model_save")):
                        os.mkdir("model_save")
                    torch.save(model, "model_save/best_ckpt.model") # best_ckpt.model 和test.ipynb文件保持一致才行
    
    
    
    
                            
  • 相关阅读:
    理解HTTP协议
    节点操作,节点属性的操作及DOM event事件
    jQuery的属性,事件及操作
    jQuery中的选择器及筛选器
    javascipt中的DOM对象
    javascript中的BOM对象
    javascript中的Date对象和Math对象
    javascript中的字符串对象
    javascript基础
    CSS核心内容之浮动
  • 原文地址:https://www.cnblogs.com/qiezi-online/p/14164893.html
Copyright © 2011-2022 走看看