PyTorch 学习：线性回归

简单的一个机器学习应用到日常的游戏运维工作：通过游戏的在线人数来预测游戏服的 CPU 利用率。

首先从 bosun 获取数据，在线人数和对应的 CPU 利用率，注意归一化：

import json  
import requests

online_payload = 'q("sum:2m-avg:application.game.online{node=xxx}", "25h", "1h")'  
cpu_payload = 'q("sum:2m-avg:rate{counter,,1}:linux.proc.cpu{name=xxx}", "25h", "1h")'

def get_data(payload):  
    resp = requests.post('http://BosunServer:8070/api/expr?date=&time=', data=payload)
    js = json.loads(resp.text)
    values = js['Results'][0]['Value']
    max_ = max([values[k] for k in values.keys()]),
    return [[values[k]] for k in sorted(values.keys())], max_

X, maxX = get_data(online_payload)  
Y, maxY = get_data(cpu_payload)

trainX = [[float(x[0])/maxX[0]] for x in X]  
trainY = [[float(y[0])/maxY[0]] for y in Y]

len(X), len(Y), maxX, maxY  

然后转成 Variable

import matplotlib.pyplot as plt

plt.rcParams['figure.figsize'] = (12,12)

import torch  
from torch.autograd import Variable  
import torch.nn.functional as F

x_data = Variable(torch.Tensor(trainX))  
y_data = Variable(torch.Tensor(trainY))  

搭模型：

class NET(torch.nn.Module):

    def __init__(self):
        super(NET, self).__init__()
        self.hidden = torch.nn.Linear(1, 10)
        self.predict = torch.nn.Linear(10, 1)

    def forward(self, x):
        out = F.relu(self.hidden(x))
        out = self.predict(out)
        return out

net = NET()  

简单的两层线性层：

NET (  
  (hidden): Linear (1 -> 10)
  (predict): Linear (10 -> 1)
)

损失函数 和 优化器：

criterion = torch.nn.MSELoss()  
optimizer = torch.optim.SGD(net.parameters(), lr=0.5)  

训练喽：

for epoch in range(100):  
    y_pred = net(x_data)
    loss = criterion(y_pred, y_data)
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    if epoch % 10 == 0:
        plt.subplot(5, 2, (epoch/10)+1)
        plt.scatter(x_data.data.numpy(), y_data.data.numpy())
        plt.plot(x_data.data.numpy(), y_pred.data.numpy(), 'r-', lw=5)
        plt.text(0.5, 0, 'Loss=%.4f' % loss.data[0], fontdict={'size': 10, 'color':  'red'}, position=(0.5, 0.5))
    if loss.data[0] < 0.0015:
        break

可以看到，loss 逐渐减少，预测曲线逐渐拟合到真实的数据上。

好了，可以用来预测新数据了，因为之前归一化了，所以要注意还原：

def pred_cpu(online):  
    cpu_pred = net(Variable(torch.Tensor([[float(online)/maxX[0]]])))
    return cpu_pred.data[0][0]*maxY[0]

pred_cpu(300)  

输出：52.789943492412576，对比监控图上的值 52.53 ，还是挺准确的。

保存：

torch.save(net, 'game_online_and_cpu_model')

# 下次加载：
# net2 = torch.load('game_online_and_cpu_model')

应用场景？

主要是通过在线人数，来判断当前 CPU 利用率是否在符合统计学的范围内。额，好像用处不太大，其实主要是用来学习 PyTorch 。。