Python ELM模型预测美国10个商店3049个商品销售量 ANN人工神经网络

本文链接：https://blog.csdn.net/qq_40811682/article/details/117959217

问题描述
美国有10个商店，每个商店有3049个商品，统计了1914天内各个商品的价格和销售数量，以及每天的属性(节日，打折活动等)，通过构建非时序模型预测1914天-1941天各个商品销售数量，使用均方误差作为评价标准。
实验数据
① 30490个商品在1941天内的价格
②30490个商品在1914天的销量(标签)
③1941天所对应的属性（节日，打折等）
其中①和③是我们需要使用的特征，③中对应很多的节日，如Purim Enc，StPatricksl，Memoriall，Mother’s day等等，使用pandas包中的dummies进行onehot编码。
②是我们需要预测的lable，这个问题是一个大规模的回归问题
实验环境
pycharm平台，python语言
实验结果
预测了1914-1941天的销量数据并写入了excel。

源码：

# -*- coding: utf-8 -*-
from sklearn.metrics import mean_squared_error
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
import pandas as pd
from sklearn.utils import shuffle
import tensorflow as tf

class RELM_HiddenLayer:
    """
        正则化的极限学习机
        :param x: 初始化学习机时的训练集属性X
        :param num: 学习机隐层节点数
        :param C: 正则化系数的倒数
    """
    def __init__(self, x, num, C=10):
        row = x.shape[0]
        columns = x.shape[1]
        rnd = np.random.RandomState()
        # 权重w
        self.w = rnd.uniform(-1, 1, (columns, num))
        # 偏置b
        self.b = np.zeros([row, num], dtype=float)
        for i in range(num):
            rand_b = rnd.uniform(-0.4, 0.4)
            for j in range(row):
                self.b[j, i] = rand_b
        self.H0 = np.matrix(self.sigmoid(np.dot(x, self.w) + self.b))
        self.C = C
        self.P = (self.H0.H * self.H0 + len(x) / self.C).I
        # .T:共轭矩阵,.H:共轭转置,.I:逆矩阵

    @staticmethod
    def sigmoid(x):
        """
            激活函数sigmoid
            :param x: 训练集中的X
            :return: 激活值
        """
        return 1.0 / (1 + np.exp(-x))
    @staticmethod
    def softplus(x):
        """
            激活函数 softplus
            :param x: 训练集中的X
            :return: 激活值
        """
        return np.log(1 + np.exp(x))
    @staticmethod
    def tanh(x):
        """
            激活函数tanh
            :param x: 训练集中的X
            :return: 激活值
        """
        return (np.exp(x) - np.exp(-x)) / (np.exp(x) + np.exp(-x))
    # 回归问题 训练

    def regressor_train(self, T):
        """
            初始化了学习机后需要传入对应标签T
            :param T: 对应属性X的标签T
            :return: 隐层输出权值beta
        """
        #       all_m = np.dot(self.P, self.H0.H)
        #       self.beta = np.dot(all_m, T)
        #       return self.beta
        all_m = np.dot(self.P, self.H0.H)
        self.beta = np.dot(all_m, T)
        return self.beta
    # 回归问题 测试

    def regressor_test(self, test_x):
        """
            传入待预测的属性X并进行预测获得预测值
            :param test_x:被预测标签的属性X
            :return: 被预测标签的预测值T
        """
        b_row = test_x.shape[0]
        h = self.sigmoid(np.dot(test_x, self.w) + self.b[:b_row, :])
        #     h = self.sigmoid(np.dot(test_x, self.w) + self.b[:b_row, :])
        result = np.dot(h, self.beta)
        #       result =np.argmax(result,axis=1)
        return result


if __name__ == '__main__':

    with tf.device("/gpu:0"):
        # 项目所在路径
        ProjectPath = 'D:/Python/RecSysProject/'
        # 数据读取及划分
        url1 = ProjectPath+'20210612/train/traincalendar.csv'
        url2 = ProjectPath+'20210612/train/trainsaleslable.csv'
        url3 = ProjectPath+'20210612/test/testcalendar.csv'
        url4 = ProjectPath+'20210612/test/testsaleslable.csv'
        url5 = ProjectPath + '20210612/FinalPrediction/precalendar.csv'
        saveurl = ProjectPath+'20210612/test/testsaleslable.csv'
        data1 = pd.read_csv(url1, sep=',', header=None)
        data2 = pd.read_csv(url2, sep=',', header=None)
        data3 = pd.read_csv(url3, sep=',', header=None)
        data4 = pd.read_csv(url4, sep=',', header=None)
        data5 = pd.read_csv(url5, sep=',', header=None)
        data1 = np.array(data1)
        data2 = np.array(data2)
        data3 = np.array(data3)
        data4 = np.array(data4)
        data5 = np.array(data5)
        data1 = shuffle(data1)
        data2 = shuffle(data2)
        data3 = shuffle(data3)
        data4 = shuffle(data4)
        data5 = np.array(data5)
        X_data = np.vstack((data1,data3))
        Y = np.vstack((data2,data4))
        # print(Y)

        # 下面3行代码就是将数据集随即按照num_train分成训练集和测试集，数据量大，就分了两部分
        num_train = 0.1
        X_train, X_, Y_train, Y_ = train_test_split(X_data, Y, test_size=num_train, random_state=20)
        X_test, X_vld, Y_test, Y_vld = train_test_split(X_, Y_, test_size=0.1, random_state=20)

        # 数据标准化处理
        stdsc = StandardScaler()
        X_train = stdsc.fit_transform(X_train)
        X_test = stdsc.fit_transform(X_test)
        X_vld = stdsc.fit_transform(X_vld)
        Y_true = Y_test

        # 不同隐藏层结果对比
        bestHiddenLayer = 1
        minMSE = 100
        for j in range(1, 10, 1):
            a = RELM_HiddenLayer(X_train, j)
            a.regressor_train(Y_train)
            predict = a.regressor_test(X_test)
            #预测结果
            # print(predict)
            #预测均方误差
            MSE = mean_squared_error(predict,Y_true)
            print('hidden- %d,MSE:%f'%(j,MSE))

            if MSE< minMSE:
                minMSE = MSE
                bestHiddenLayer = j
                result = predict
        print('训练结束，训练数据中最佳隐含层网络节点数量为:%d,MSE=%f' %(bestHiddenLayer,minMSE))

        print('开始计算1914-1941结果！')
        result = []
        a = RELM_HiddenLayer(X_train, bestHiddenLayer)
        a.regressor_train(Y_train)
        predict = a.regressor_test(data5)
        predict = np.round(abs(predict))

        calendar = pd.read_csv(ProjectPath+'20210612/sales_train.csv')
        # print(calendar.iloc[0:27967, 1919:1947].shape)
        # print(predict.T.shape)
        calendar.iloc[0:27967, 1919:1947] = predict.T
        calendar.to_csv(ProjectPath+'20210612/pre_result_sales_train.csv', header=True, index=False)
        print('写入完毕！')