devbox
人工智能uu
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

学生成绩排名预测(DC)_学生成绩预测

作者：人工智能uu | 2024-07-12 19:52:53

赞

踩

学生成绩预测

去年大数据分析课程的选题项目，最近考研不顺整理之前的杂碎半成品等丰富一下简历，准备找工作二战了，真是一个悲伤的现实，唉。

原题目链接：DC竞赛：学生成绩排名预测 【已挂】

相关数据：https://github.com/typeisgod/CSDN

题目背景和意义：

    我们希望通过借助大数据相关的挖掘技术和基础算法，从学生的校园行为数据中，根据学生出入图书馆的次数，以及借书和消费情况等，挖掘用户作息规律、兴趣爱好等，精准地预测学生之间的相对排名。通过对这些日常行为的建模来预测学生的学业成绩，发现学生成绩和日常校园行为之间的潜在关系，可以实现提前预警学生的异常情况，并进行适当的干预，因而对学生的培养、管理工作将会起到极其重要的作用。

题目描述：

    本次竞赛中，我们将从某高校的某个学院随机抽取一定比例学生，提供这些学生在三个学期的图书馆进出记录、一卡通消费记录、图书馆借阅记录、以及综合成绩的相对排名。这一部分数据将作为训练数据。我们从另外的某学院随机抽取一定比例的学生，然后提供他们在三个学期的图书馆进出记录、一卡通消费记录、图书借阅记录、以及前两个学期的成绩排名。第三学期的成绩排名作为预测目标。

提供文件：

    训练\成绩.txt。训练集的成绩文件，包含学期、学号、以及相对排名

    训练\借书.txt。训练集的图书借阅信息，包含学期、学号、书号、日期

    训练\图书门禁.txt。 训练集的图书门禁进入，包含学期、学号、日期、时间

    训练\消费.txt。训练集的消费数据，包含学期、学号、地点、日期、时间、金额

    测试\成绩.txt。 测试集的成绩文件。字段同上 测试\借书.txt。 测试集的图书借阅信息。字段同上

    测试\图书门禁.txt。 测试集的图书门禁进入。字段同上

    测试\消费.txt。 测试集的消费数据。字段同上

评估标准：

    算法通过衡量预测排名和实际排名的Spearman相关性，为[0,1]之间的值，值越大，表示越相关，排名的预测就越准确。若要考虑n个学生的排名，学生i的预测排名为pi，而实际的排名为ri，di = pi - ri，那么

                                                     

本数据统计模型(最后评分并不是很高，仅供参考)：

后来觉得次数不一定决定成绩，应该还有稳定性。后来对门禁和借书计算了每个学期的月均值、月方差、日均值、日方差(第一、三学期五个月 第二学期六个月 每个月三十一天计算)，扩展到了317维。之后归一化到了[0,1]之间。

我做的工作：提取成绩、图书馆门禁、借书；分析预测

汪东启的工作：提取图书类别（供借书使用）、消费；多维合并

一.书籍信息读取、检查与存储(汪东启)

  0. 图书类别.txt 文件预览与格式：

  1.文件的预读取与检查(test_check_book.py)

  1. # -*- coding: utf-8 -*-
  2. """
  3. Created on Mon May  7 14:53:24 2018
  5. @author: wangdongqi
  7. 读取书籍信息，检查数据中可能出现的问题
  8. """
  9.  
  10. Book = dict()
  11. ClassNum = []
  12. err = []
  13.  
  14. with open('图书类别.txt', encoding = 'utf-8') as f:
  15.     f.readline();
  16.     for line in f:
  17.         (BookNumber, BookClass) = line.split('\t');
  18.         if BookNumber not in Book.keys():
  19.             Book[BookNumber] = [BookClass]
  20.         else:
  21.             Book[BookNumber].append(BookClass)
  22.             print(BookNumber)
  23.             err.append(BookNumber)
  24.         if BookClass not in ClassNum:
  25.             ClassNum.append(BookClass);
  26.  
  27. # 测试重复的那些数据是否有变化
  28. err_list = []
  29. for i in err:
  30.     tmp_list = Book[i]
  31.     tmp = tmp_list[0]
  32.     for j in tmp_list[1:]:
  33.         if j != tmp:
  34.             err_list.append(i)
  35.             break
  36. # 结论：所有重复的数据的信息相同，对结果无影响
  37.  
  38.  
  39.

2.数据提取(test_read_book)

首先导入文件，将文件按行切分(split，代码使用replace直接替换)为BookNumber和bookclass，检查BookNumber是否为数字（防止图书编号中出现错切分的其他符号），如果是则放入字典BookInfo中；同时BookClass为list类型，用于存放一共出现的bookclass的种类数（文件中只有42种，但在其他文件中出现未在字典中的书籍，收集作为第43类）。最后通过pickle.load函数将BookInfo和BookClass数组存放下pkl中。

  1. # -*- coding: utf-8 -*-
  2. """
  3. Created on Mon May  7 15:49:55 2018
  5. @author: wangdongqi
  7. 读取书籍信息
  8. """
  9. BookInfo = dict()
  10. errInfo = dict()
  11. BookClass = []
  12.  
  13. with open('图书类别.txt', encoding = 'utf-8') as f:
  14.     f.readline();
  15.     for line in f:
  16.         line = line.replace('\n', '')
  17.         (BookNumber, bookclass) = line.split('\t');
  18.         if not BookNumber.isdigit():
  19.             errInfo[BookNumber] = bookclass
  20.             continue
  21.         
  22.         BookInfo[BookNumber] = bookclass
  23.         if bookclass not in BookClass:
  24.             BookClass.append(bookclass)
  25.         
  26.  
  27. # 排序
  28. BookClass.sort()
  29.  
  30. # 打印42类书的类名
  31. for i in BookClass:
  32.     print(i, end = ' ')
  33.     
  34.  
  35.  
  36. # 保存信息
  37. import pickle
  38.  
  39. # 保存
  40. pickle.dump(BookInfo, open('BookInfo.pkl', 'wb'))
  41. pickle.dump(BookClass, open('BookClass.pkl', 'wb'))
  42.  
  43. # 读取
  44. BookInfo = pickle.load(open('BookInfo.pkl', 'rb'))
  45. BookClass = pickle.load(open('BookClass.pkl', 'rb'))
  46.  
  47.  
  48.  
  49.  
  50.  
  51.

二.成绩、图书馆门禁、借书提取(Type) (pre.py)

0.文件预览与格式

1.

依次读入成绩、图书馆门禁、借书三个txt文件，分别存入file_rank、file_ibrary、file_borrow变量中。

(1)file_rank：

每次读取一行(readline()),对每行未使用split等切割，而是手动实现的“字符切割”：(代码25-39行)

   pre为某个字符段(数字段)的开始，初始化0，end为某个字符段(数字段)的结束，当没有扫描到行末尾时循环查找，当下标为pre的字符不为空(/t)时，end一直循环到下一个空(/t)或末尾的上一个字符(数字段结尾)，然后取[pre:end]（end不取），依次取数组段直到pre到行末，得到的多个数字段放入temp中，并合并到总data里(二维数组)，读取下一行。全部读完后以学号为主key，学期为副key对data排序：data=sorted(data,key=lambda x:(x[1],x[0]))

此时data格式为：

学期学号排名

(2)file_library:

新增 月平均 月方差 月最大 月最小 
        日平均  日方差 日最大 日最小
        06-22 小时点次数

(PS:月平均：平均每个月去图书馆的门禁次数，月最大：最多一个月去的门禁次数，其他同理

小时点次数：这个学期每个小时门禁次数汇总情况，并非每天每小时的次数)
新增共 25 维（最开始的模型只有下标3 新增4-28）

下标（从0开始）01234-78-1112-28
维/属性学期学号排名本学期图书馆门禁次数月平均 月方差 月最大 月最小日平均  日方差 日最大 日最小06-22 小时点次数

从file_library提取的数据共26维(data下标对应3-28)，建立一个和data等长(len(data)的)三维数组data3，用于存放每个学期每个学生每个月每天的图书馆门禁次数。

data3=np.zeros(shape=(len(data),6,31)).tolist();

用split('\t')分割每行为四个数字段，分别对应学期、学号、日期、时间。(代码中ent为回车符)，通过学期和学号即可计算出对应data中的下标：index=(sid-1)*3+seme-1; （sid=学号，seme=学期）。

从时间提取出前二位数为小时hour([0:2]),同理从日期中提取出月份month和天day。并根据学期将每个学期的月份最低数规划到0，分别将每个月每天的次数存入data3中，将每小时（06时-22时）的门禁次数写入data中。(此上代码75-90行)

统计完毕后计算月均值mmean、月最大mmax、月最大mmax、月最小mmin、月方差mvar、日均值mmean、日最大mmax、日最大mmax、日最小mmin、日方差mvar并放入data的[4:12]中。

(3) file_borrow:(使用 一 中已经写好的pkl作为字典索引类别)

下标（从0开始）0123-2829-7172-7576-79
维/属性学期学号排名file_library提取的属性列每类书的借阅总次数（本数）月平均  月方差 月最大 月最小日平均  日方差 日最大 日最小

读入pkl和file_library类似地统计每个人每个学期每类书(43类，用ABCD等表示)的总次数，和所有类型书的借阅月总次数、最大、最小、方差、日同理。

代码pre.py:

  1. # -*- coding: utf-8 -*-
  2. """
  3. Created on Mon May  7 13:28:12 2018
  5. @author: Type真是太帅了
  6. """
  7. import numpy as np
  8. import pickle
  9. file_rank=open('成绩.txt','r')
  10. file_library=open('图书馆门禁.txt','r')
  11. file_borrow=open('借书.txt','r')
  12. file_consume=open('消费.txt','r')
  13. #file_type=open('图书类别.txt','r')
  14.  
  15. '''
  16.  学期 学号 图书馆门禁次数 食堂总消费 交通总消费 宿舍总消费 超市总消费 书类别  排名
  17. '''  
  18. data=[]
  19. '''
  20. 读入成绩
  21. '''
  22. line = file_rank.readline()
  23. line = file_rank.readline()#直接读取第二行数据 
  24. while line:  
  25.     temp=[]
  26.     pre=0
  27.     while pre<len(line)-2: #对于每行line的每个字符 将其转化为数字形式并存储于数组中 最后\n两个字符不读
  28.         if line[pre]!='\t':
  29.             end=pre+1
  30.             while end<len(line)-1:
  31.                 if line[end]=='\t':
  32.                     temp=temp+[int(line[pre:end])]
  33.                     pre=end+1
  34.                     break
  35.                 else:
  36.                     end=end+1
  37.         else:
  38.             pre=pre+1
  39.             end=pre+1
  40.     data=data+[temp]
  41.     line = file_rank.readline()  
  42. '''
  43. 以学号为主key 学期为负key进行排序
  44. '''
  45. data=sorted(data,key=lambda x:(x[1],x[0]))
  46.  
  47. '''
  48. 读入图书馆门禁次数(学期计)
  49. '''
  50.  
  51. '''
  52. 新增 月平均 月方差 月最大 月最小 
  53.      日平均  日方差 日最大 日最小
  54.     06-22 小时点次数
  55.     共 25 维
  56. 0    1    2    3    4567 891011      12-28 29-71
  57. 学期 学号 排名  总数 月   日          06-22  1-43
  58. '''
  59. line = file_library.readline()
  60. line = file_library.readline()#直接读取第二行数据 
  61. zero26=np.zeros(26,int).tolist();#新建26维列表
  62. i=0
  63. while i<len(data):
  64.     data[i]=data[i]+zero26;
  65.     i=i+1
  66.  
  67. data3=np.zeros(shape=(len(data),6,31)).tolist();#统计每天的次数 每个月取31天 
  68. '''1/3学期 data3[index][0-4]表示 9-1月 9~0 10~1 11~2 12~3 1~4
  69.      2学期 data3[index][0-5]表示 2-7月
  70. '''
  71. n_1=5;#1 3 学期 5个月
  72. n_2=6;# 2 学期 6个月
  73. while line:
  74.     readtime=0#记录读取次数 第一次读学期 第二次为学号
  75.     (seme,sid,date,time,ent)=line.split('\t')
  76.     seme=int(seme);
  77.     sid=int(sid);
  78.     index=(sid-1)*3+seme-1;#第seme的第sid号学生在data中的下标号  
  79.     data[index][3]+=1;#学期签到总数
  80.     offset=6;#小时签到次数对应data列的偏移量
  81.     #统计小时签到次数
  82.     hour=int(time[0:2]);
  83.     data[index][hour+offset]+=1;
  84.     month=int(date[0:2]);
  85.  
  86.     day=int(date[2:])
  87.     if seme!=2:
  88.         data3[index][(month-9)%12][day-1]+=1;
  89.     else:
  90.         data3[index][month-2][day-1]+=1;
  91.     line = file_library.readline()
  92.     
  93. '''
  94. 根据data2和data3求均值 最大 最小 方差 并写入到data里
  95. '''    
  96. i=0
  97. while i<len(data):
  98.     if i%3==1:#是否为第二学期
  99.         n=n_2;
  100.     else:
  101.         n=n_1;
  102.     mmean=data[i][3]/n;
  103.     dmean=data[i][3]/(n*31);
  104.     m=np.zeros(n,int).tolist();#该人每个人的总数
  105.     d=np.zeros(n*31,int).tolist()#该人每天的总数
  106.     j=0#第j个月
  107.     l=0#该学期第l天
  108.     while j<n:
  109.         m[j]=int(sum(data3[i][j]))
  110.         k=0#第j月中的k天
  111.         while k<31:
  112.             d[l]=int(data3[i][j][k])
  113.             l=l+1
  114.             k=k+1
  115.         j=j+1
  116.     mmax=max(m);
  117.     dmax=max(d);
  118.     mmin=min(m);
  119.     dmin=min(d);
  120.     mvar=np.var(m);
  121.     dvar=np.var(d);
  122.     data[i][4:12]=mmean,mvar,mmax,mmin,dmean,dvar,dmax,dmin;
  123.     i=i+1
  124. '''
  125. 借书
  126. '''
  127. """
  128. 读取书籍信息
  129. """
  130.  
  131. BookInfo = dict()
  132. BookClass = ['A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','TB','TD','TE','TF','TG','TH','TJ','TK','TL','TM','TN','TP','TQ','TS','TT','TU','TV','U','V','X','Y', 'Z','OO']
  133. '''
  134. pickle.dump(BookInfo,open('BookInfo.pkl','wb'))
  135. '''
  136. '''
  137. with open('图书类别.txt', encoding = 'utf-8') as f:
  138.     f.readline();
  139.     for line in f:
  140.         line = line.replace('\n', '')
  141.         (BookNumber, bookclass) = line.split('\t');
  142.         if not BookNumber.isdigit():
  143.             continue
  144.         
  145.         BookInfo[BookNumber] = bookclass
  146. '''
  147. '''
  148. 新增内容：
  149. 72 74 74 75     76 77 78 79
  150. 月总借书        日总借书
  151. 均值 方差 最大 最小
  152. ☞统计各种类书之和
  153. '''
  154. data2=np.zeros(shape=(len(data),6,31)).tolist();#统计每个学期每个人 某月的第某天借了几本书
  155.  
  156. BookInfo=pickle.load(open('BookInfo.pkl','rb'))
  157. zero43=np.zeros(43,int).tolist()
  158. i=0
  159. offset=30 #书类别偏移
  160. while i<len(data):
  161.     data[i]+=zero43
  162.     i=i+1
  163. line=file_borrow.readline()
  164. line=file_borrow.readline()
  165.  
  166. while line:
  167.     (seme,sid,name,date,ent)=line.split('\t')
  168.     index=(int(sid)-1)*3+int(seme)-1
  169.     month=int(date[:2])
  170.     day=int(date[2:])
  171.     if int(seme)!=2:
  172.         data2[index][(month-9)%12][day-1]+=1;
  173.     else:
  174.         data2[index][month-2][day-1]+=1;
  175.     if name not in BookInfo.keys():
  176.         data[index][42+offset-1]+=1
  177.     else:
  178.         i=0
  179.         while i<len(BookClass)-1:
  180.             if BookClass[i]==BookInfo[name]:
  181.                 break;
  182.             i=i+1
  183.         data[index][i+offset-1]+=1
  184.     line=file_borrow.readline()
  185. i=0
  186. '''
  187. 计算月 日 放进 data
  188. '''
  189. zeros8=np.zeros(8,int).tolist();
  190. while i<len(data):
  191.     data[i]+=zeros8
  192.     i=i+1
  193. i=0
  194. while i<len(data):
  195.     if i%3==1:
  196.         n=n_2
  197.     else:
  198.         n=n_1
  199.     num=sum(data[i][offset-1:])#某个人某学期总借书量
  200.     mmean=num/n;
  201.     dmean=num/(n*31);
  202.     m=np.zeros(n,int).tolist();
  203.     d=np.zeros(n*31,int).tolist();
  204.     j=0#第j个月
  205.     l=0#该学期第l天
  206.     while j<n:
  207.         m[j]=int(sum(data2[i][j]))
  208.         k=0#第j月中的k天
  209.         while k<31:
  210.             d[l]=int(data2[i][j][k])
  211.             l=l+1
  212.             k=k+1
  213.         j=j+1
  214.     mmax=max(m);
  215.     dmax=max(d);
  216.     mmin=min(m);
  217.     dmin=min(d);
  218.     mvar=np.var(m);
  219.     dvar=np.var(d);
  220.     data[i][72:]=mmean,mvar,mmax,mmin,dmean,dvar,dmax,dmin;
  221.     i=i+1
  222.     
  223.     
  224. ''' 学期、学号、排名、门禁、书籍信息 '''
  225. #pickle.dump(data, open('data_pre.pkl', 'wb'))

三 消费(汪东启，test_cost_read.py)

文件预览与格式：

(好像他给我说有的人一学期没有消费记录的，被他处理掉了，而且他把时间和日期之类的并没有考虑进来，当时我给他提出我的均值-最大-最小-方差体系的时候，他觉得很费劲没做，最后似乎就是统计了一下每类(食堂、宿舍、超市等)每人每学期的总消费）test_cost_read.py

  1. # -*- coding: utf-8 -*-
  2. """
  3. Created on Mon May  7 16:49:02 2018
  5. @author: wangdongqi
  7. 读取消费信息[term, stuID, place, date, time, cost]
  9. data、time两项暂定去除，不参与训练
  11. bug: 排序前将学号及学期改为数字，否则排序会错误
  12. """
  13.  
  14. ''' ------------------读取消费信息----------------------- '''
  15. data = []
  16. with open('消费.txt') as f:
  17.     f.readline();
  18.     for line in f:
  19.         line = line.replace('\n', '')
  20.         tmp_list = line.split('\t')
  21.         tmp_list = [int(tmp_list[0]), int(tmp_list[1]), tmp_list[2], 
  22.                     int(tmp_list[3]), int(tmp_list[4]), float(tmp_list[5])]
  23.         data.append(tmp_list)
  24.         
  25. ''' -------------------获得地点列表---------------------- '''
  26. # 检查数据中的所有地点项
  27. AllPlace = [i[2] for i in data]
  28. AllPlace = list(set(AllPlace))
  29. AllPlace.sort()
  30. # 检查结果：['食堂', '交通', '超市', '宿舍', '教室', '图书馆', '打印']
  31.  
  32. ''' --------------------进行排序--------------------- '''
  33. # 排序顺序：学号 > 学期 > 地点
  34. sort_list = sorted(data, key = lambda x : (x[1], x[0], x[2]))
  35.  
  36. ''' ------------把相同地点的花费合并在一起------------- '''
  37. # 把相同地点的花费合并到一起
  38. resolve_list = []
  39. iterator = 0
  40. while iterator < len(sort_list):
  41.     item = sort_list[iterator]
  42.     
  43.     # 获得基本信息
  44.     info = item[:3]
  45.     
  46.     # 计算在某个地点的花费情况
  47.     cost = item[-1]
  48.     while iterator + 1 < len(sort_list) and info == sort_list[iterator + 1][:3]:
  49.         iterator += 1
  50.         cost += sort_list[iterator][-1]
  51.     
  52.     # 学号和学期转换为int类型，加入在某个地点处的消费情况
  53.     info.append(round(cost, 2))
  54.     resolve_list.append(info)
  55.     
  56.     iterator += 1
  57. # 格式：[学期（int），学号（int），地点，花费（float）]
  58.  
  59. ''' ----------把每学期每个同学的消费情况合并------------- '''
  60. # 把每个学期每个同学的消费情况整理到一个数组中
  61. header = AllPlace
  62. iterator = 0
  63. result = []
  64. while iterator < len(resolve_list):
  65.     item = resolve_list[iterator]
  66.     
  67.      # 获得基本信息
  68.     info = item[:2]
  69.     
  70.     # 统计在每个地点的消费情况
  71.     cost = dict()
  72.     cost[item[2]] = item[3]
  73.     while iterator + 1 < len(resolve_list) and info == resolve_list[iterator + 1][:2]:
  74.         iterator += 1
  75.         cost[resolve_list[iterator][2]] = resolve_list[iterator][3]
  76.     
  77.     # 整理到一个列表中
  78.     cost_result = []
  79.     for i in header:
  80.         if i in cost.keys():
  81.             cost_result.append(cost[i])
  82.         else:
  83.             cost_result.append(0)
  84.     
  85.     # 整合到一起
  86.     info = info + cost_result
  87.     result.append(info)
  88.     
  89.     iterator += 1
  90.     
  91. ''' ------------------补全信息----------------------- '''
  92. # 把缺失的信息填补（置为0） 538个人 * 3个学期
  93. index = 0
  94. CostInfo = []
  95. for i in range(1, 538 + 1):
  96.     for j in range(1, 3 + 1):
  97.         if result[index][:2] == [j, i]:
  98.             CostInfo.append(result[index])
  99.             index += 1
  100.         else:
  101.             CostInfo.append([j, i, .0, .0, .0, .0, .0, .0, .0])
  102.         
  103.  
  104.  
  105.  
  106. ''' ------------------保存信息----------------------- '''
  107. import pickle
  108.  
  109. # 保存
  110. pickle.dump(AllPlace, open('AllPlace.pkl', 'wb'))
  111. pickle.dump(CostInfo, open('CostInfo.pkl', 'wb'))
  112.  
  113. # 读取
  114. # =============================================================================
  115. # AllPlace = pickle.load(open('AllPlace.pkl', 'rb'))
  116. # result = pickle.load(open('CostInfo.pkl', 'rb'))
  117. # =============================================================================
  118.

四 数据连接与重组（汪东启,Combine_data.py）

在这里把上边三部分产生的数据都存入了pkl文件中（pre的为pre_data.pkl),由于似乎每个学期之间是相互关联的（测试集为给你前两个学期的排名等信息和第三个学习的门禁等信息，预测第三个学期的排名），于是把每个人第二学期和第三学期的信息合并在了第一学期的右部分，即把每三列拉伸为一列：

把每个学期的排名放在每个学期的最后一列，同时去掉了学号、学期列。

抽出除最后一列的其他列作为train_x，最后一列作为train_y，保存在pkl中。

对于测试集同样处理，得到test_x，test_y从sample_submission.csv里直接读取。

Combine_data.py：

  1. # -*- coding: utf-8 -*-
  2. """
  3. Created on Sat May 12 14:13:18 2018
  5. @author: wangdongqi
  7. 组合所有的数据
  8. """
  9. import numpy as np
  10. import pickle
  11.  
  12. data_pre = pickle.load(open('data_pre.pkl', 'rb'))
  13.  
  14. AllPlace = pickle.load(open('AllPlace.pkl', 'rb'))
  15. BookClass = pickle.load(open('BookClass.pkl', 'rb')) + ['OO']
  16. BookInfo = pickle.load(open('BookInfo.pkl', 'rb'))
  17. CostInfo = pickle.load(open('CostInfo.pkl', 'rb'))
  18.  
  19. if len(data_pre) != len(CostInfo):
  20.     raise RuntimeError('信息不一致')
  21.  
  22. length = len(data_pre)
  23.  
  24. Data = []
  25. for index in range(length):
  26.     if data_pre[index][:2] == CostInfo[index][:2]:
  27.         Data.append(data_pre[index] + CostInfo[index][2:])
  28.     else:
  29.         raise RuntimeError('信息错误')
  30.     
  31. labels = ['term', 'stuID', 'score', 'LibDoor']
  32. labels = labels + BookClass + AllPlace
  33.  
  34. '''
  35. 存储格式：学期，学号，排名，门禁，
  36. '''
  37.  
  38. pickle.dump(Data, open('Data.pkl', 'wb'))
  39. pickle.dump(labels, open('labels.pkl', 'wb'))
  40.  
  41.  
  42. '''
  43. 把三个学期的成绩合在一起，不要学期，学号，成绩放在最后
  44. '''
  45. label_tmp1 = ['term1_' + i for i in labels[3:]] + ['term1_score']
  46. label_tmp2 = ['term2_' + i for i in labels[3:]] + ['term2_score']
  47. label_tmp3 = ['term3_' + i for i in labels[3:]]
  48. train_label = label_tmp1 + label_tmp2 + label_tmp3
  49.  
  50. pickle.dump(train_label, open('train_label.pkl', 'wb'))
  51.  
  52. train_x = []
  53. train_y = []
  54. for index in range(int(len(Data) / 3)):
  55.     tmp = []
  56.     for i in range(3):
  57.         d = Data[index * 3 + i]
  58.         tmp = tmp + d[3:] + [d[3]]
  59.     train_x.append(tmp[:-1])
  60.     train_y.append(tmp[-1])
  61.  
  62. pickle.dump(train_x, open('train_x.pkl', 'wb'))
  63. pickle.dump(train_y, open('train_y.pkl', 'wb'))

五：分析与预测（Type）

这个不多bb直接读入train_x、train_y、test_x、test_y，然后放入各种model预测分析就好了。

  1. # -*- coding: utf-8 -*-
  2. """
  3. Created on Mon May 21 15:07:52 2018
  5. @author: 71405
  6. """
  7.  
  8. import pickle
  9. dir_name = './'
  10. x1=pickle.load(open(dir_name + 'train_x.pkl','rb'))
  11. y1=pickle.load(open(dir_name + 'train_y.pkl','rb'))
  12. x2=pickle.load(open(dir_name + 'test_x.pkl', 'rb'))
  13. y2=pickle.load(open(dir_name + 'test_y.pkl', 'rb'))
  14.  
  15.  
  16. #Label=pickle.load(open('train_label.pkl','rb'))
  17. from sklearn.ensemble import RandomForestRegressor
  18. from sklearn.neighbors import KNeighborsClassifier  
  19. from sklearn import svm 
  20. import numpy as np
  21.  
  22. # 把训练数据归一化
  23. def Normalization(train_data, test_data):
  24.     train_normal_data = np.zeros(train_data.shape, dtype = 'float')
  25.     test_normal_data = np.zeros(test_data.shape, dtype = 'float')
  26.     
  27.     max_num = []
  28.     
  29.     if len(train_data.shape) == 2:
  30.         # 训练数据
  31.         for col in range(train_data.shape[1]):
  32.             col_data1 = train_data[..., col]
  33.             col_data2 = test_data[..., col]
  34.             
  35.             max_data = max(max(col_data1), max(col_data2))
  36.             min_data = 0
  37.             max_num.append(max_data)
  38.             
  39.             col_data1 = (col_data1 - min_data) / (max_data - min_data + 1)
  40.             col_data2 = (col_data2 - min_data) / (max_data - min_data + 1)
  41.             
  42.             train_normal_data[..., col] = col_data1
  43.             test_normal_data[..., col] = col_data2
  44.     
  45.     return train_normal_data, test_normal_data, max_num
  46.     
  47.     
  48.  
  49. x_train=np.array(x1)
  50. y_train=np.array(y1)
  51. x_test=np.array(x2)
  52. y_test=np.array(y2)
  53.  
  54. x_train, x_test, max_num = Normalization(x_train, x_test)
  55. y_train = y_train / max(y_train)
  56.  
  57. # model = KNeighborsClassifier(10)
  58. # model=svm.SVC(C=2, kernel='linear',decision_function_shape='ovr')
  59. model = RandomForestRegressor(1000)
  60. model.fit(x_train,y_train)
  61. scores=model.score(x_test,y_test)
  62. y_predict=model.predict(x_test)
  63. scores=model.score(x_test,y_test)
  64. i=0
  65. t=0
  66.  
  67. def sort_predict(y_predict):
  68.     y = np.zeros(y_predict.shape)
  69.     
  70.     max_ = max(y_predict)
  71.     for index in range(len(y_predict)):
  72.         min_index = y_predict.argmin()
  73.         y[min_index] = index + 1
  74.         y_predict[min_index] = max_ + 1
  75.     
  76.     return y
  77.  
  78. y_predict = sort_predict(y_predict)
  79.  
  80. while i<len(y_predict):
  81.     if(abs(round(y_predict[i])-y_test[i]) <= 3):
  82.         t=t+1
  83.     i=i+1
  84. t=t/len(y_predict)
  85.  
  86. n = len(y_predict)
  87. rou = 1 - 1 * sum((y_predict - y_test) ** 2) / (n * (n ** 2 - 1))

最后的评分好像只有0.84（满分1）

PS：之前第一版代码中，数据连接（Combine_data）中出现了错误提取，导致最后的评分超级高（训练集提取一部分训练另一部分测试时接近于1，而测试集测试时评分是负值，后来发现在训练集的data里提出了排名列而未删掉，似乎是删错了列，然后分析的时候排名列权值接近于1）；由于年久失修，可能贴的代码为最老的代码，有部分错误，然后想找最新版的时候找到了一些他改造后的乱七八糟的代码，就随便贴一下：

read_data.py:（这个应该是最后正确的连接，pre2和pre_treat为之前的pre代码改造版）

  1. # -*- coding: utf-8 -*-
  2. """
  3. Created on Thu Jun  7 09:06:31 2018
  5. @author: Administrator
  7. 读取数据的函数
  8. """
  9.  
  10. import numpy as np
  11. import pickle
  12. from pre_treat import pre_train
  13. from pre2 import pre_test
  14.  
  15. def SaveData(Data, filename):
  16.     pickle.dump(Data, open(filename, 'wb'))
  17.  
  18. def LoadData(filename):
  19.     return pickle.load(open(filename, 'rb'))
  20.  
  21. # 读取图书类别信息
  22. def read_bookinfo(bookinfo_path):
  23.     BookInfo = dict();
  24.     errBookInfo = dict();
  25.     BookClass = [];
  26.     
  27.     with open('图书类别.txt', encoding = 'utf-8') as f:
  28.         f.readline();
  29.         for line in f:
  30.             line = line.replace('\n', '')
  31.             (BookNumber, bookclass) = line.split('\t');
  32.             if not BookNumber.isdigit():
  33.                 errBookInfo[BookNumber] = bookclass
  34.                 continue
  35.             
  36.             BookInfo[BookNumber] = bookclass
  37.             if bookclass not in BookClass:
  38.                 BookClass.append(bookclass)
  39.     
  40.     # 排序
  41.     BookClass.sort()
  42.     
  43.     # 保存
  44.     SaveData(BookInfo, 'BookInfo.pkl')
  45.     SaveData(errBookInfo, 'errBookInfo.pkl')
  46.     SaveData(BookClass, 'BookClass.pkl')
  47.     
  48.     return BookInfo, errBookInfo, BookClass
  49.  
  50. # 读取消费信息文件
  51. def read_cost(cost_path, people_num = 0):
  52.     ''' ------------------读取消费信息----------------------- '''
  53.     ''' 消费信息：[term, stuID, place, date, time, cost] '''
  54.     cost_data = []
  55.     AllPlace = []
  56.     with open(cost_path) as f:
  57.         f.readline();
  58.         for line in f:
  59.             line = line.replace('\n', '')
  60.             
  61.             tmp_list = line.split('\t')
  62.             tmp_list = [int(tmp_list[0]), int(tmp_list[1]), tmp_list[2], 
  63.                         int(tmp_list[3]), int(tmp_list[4]), float(tmp_list[5])]
  64.             
  65.             cost_data.append(tmp_list)
  66.             AllPlace.append(tmp_list[2])
  67.     
  68.     ''' -------------------获得地点列表---------------------- '''
  69.     AllPlace = list(set(AllPlace))
  70.     AllPlace.sort()
  71.     # 检查结果：['食堂', '交通', '超市', '宿舍', '教室', '图书馆', '打印']
  72.     
  73.     ''' --------------------进行排序--------------------- '''
  74.     # 排序顺序：学号 > 学期 > 地点
  75.     sort_key = [1, 0, 2, 3, 4, 5]
  76.     sorted_list = sorted(cost_data, key = lambda x : (x[sort_key[0]], x[sort_key[1]], x[sort_key[2]], x[sort_key[3]], x[sort_key[4]], x[sort_key[5]]))
  77.     
  78.     ''' ------------把所有数据合并到同一个字典中------------- '''
  79.     resolve_dict = dict();
  80.     
  81.     for item in sorted_list:
  82.         tmp = resolve_dict
  83.         for index in range(4):
  84.             if item[index] in tmp.keys():
  85.                 pass
  86.             else:
  87.                 tmp[item[index]] = dict()
  88.             tmp = tmp[item[index]]
  89.         
  90.         if item[4] not in tmp.keys():
  91.             tmp[item[4]] = []
  92.         tmp = tmp[item[4]]
  93.         
  94.         tmp.append(item[5])
  95.     
  96.     ''' -------处理数据--------- '''
  97.     if people_num == 0:
  98.         people_num = 0
  99.         for i in resolve_dict:
  100.             people_num = max(people_num, max(resolve_dict[i]))
  101.     
  102.     new_info = []
  103.     for people in range(1, people_num + 1):
  104.         # 学号
  105.         people_info = []
  106.         
  107.         err_term = []
  108.         for term in range(1, 4):
  109.             # 学期 最大 最小 总和 次数
  110.             if people not in resolve_dict[term].keys():
  111.                 people_info.extend([0] * 28)
  112.                 err_term.append(term)
  113.                 continue
  114.             
  115.             for place in AllPlace:
  116.                 if place not in resolve_dict[term][people].keys():
  117.                     people_info.extend([0] * 4)
  118.                     continue
  119.                 
  120.                 # 地点
  121.                 cost_info = resolve_dict[term][people][place]
  122.                 every_cost = []
  123.                 for key1 in cost_info:
  124.                     for key2 in cost_info[key1]:
  125.                         every_cost.extend(cost_info[key1][key2])
  126.                     
  127.                 max_num = max(every_cost)
  128.                 min_num = min(every_cost)
  129.                 sum_num = sum(every_cost)
  130.                 times = len(every_cost)
  131.                 people_info.extend([max_num, min_num, sum_num, times])
  132.         
  133. # =============================================================================
  134. #         # 如果某个学期全部为0的处理
  135. #         if len(err_term) != 0:
  136. #             True_term = []
  137. #             for i in range(1, 4):
  138. #                 if i not in err_term:
  139. #                     True_term.append(people_info[(i - 1) * 28 : i * 28])
  140. #             True_info = [0] * 28
  141. #             True_num = 0
  142. #             for i in True_term:
  143. #                 True_info = [True_info[j] + i[j] for j in range(28)]
  144. #                 True_num += 1
  145. #             if True_num != 0:
  146. #                 True_info = [i / True_num for i in True_info]
  147. #             for i in err_term:
  148. #                 people_info[(i - 1) * 28 : i * 28] = True_info
  149. #         
  150. # =============================================================================
  151.         tmp = [people] + people_info
  152.         new_info.append(tmp)
  153.     
  154.     SaveData(new_info, 'cost_info.pkl')
  155.     
  156.     return new_info
  157.  
  158. # 读取图书馆门禁文件
  159. def read_library(liabrary_path):
  160.     
  161.     pass
  162.  
  163. # 读取借书文件
  164. def read_borrow(borrow_path):
  165.     
  166.     pass
  167.  
  168. # 读取成绩文件
  169. def read_rank(rank_path):
  170.     
  171.     pass
  172.  
  173. def combine_train():
  174.     cost_path = './training/消费.txt'
  175.     cost = read_cost(cost_path)
  176.     # 先运行pre
  177.     train_predata_x, train_y = pre_train()
  178.     train_x = []
  179.     for i in range(538):
  180.         train_x.append(cost[i][1:] + train_predata_x[i][1:])
  181.     
  182.     SaveData(train_x, './train_x.pkl')
  183.     SaveData(train_y, './train_y.pkl')
  184.     
  185.     return train_x, train_y
  186.  
  187. def combine_test():
  188.     cost_path = './test/消费.txt'
  189.     cost = read_cost(cost_path, 91)
  190.     # 先运行pre
  191.     test_predata_x, test_y = pre_test()
  192.     test_x = []
  193.     for i in range(91):
  194.         test_x.append(cost[i][1:] + test_predata_x[i][1:])
  195.     
  196.     SaveData(test_x, './test_x.pkl')
  197.     SaveData(test_y, './test_y.pkl')
  198.     
  199.     return test_x, test_y
  200.  
  201. #x,y = combine_train()
  202. test_x, test_y = combine_test()
  203. train_x, train_y = combine_train()

pre2.py：

  1. # -*- coding: utf-8 -*-
  2. """
  3. Created on Mon May  7 13:28:12 2018
  5. @author: Type真是太帅了
  6. """
  7. import numpy as np
  8. import pickle
  9.  
  10. def pre_test():
  11.     file_rank=open('./test/成绩.txt','r')
  12.     file_library=open('./test/图书馆门禁.txt','r')
  13.     file_borrow=open('./test/借书.txt','r')
  14.     file_consume=open('./test/消费.txt','r')
  15.     file_type=open('图书类别.txt','r')
  16.     
  17.     '''
  18.      学期 学号 图书馆门禁次数 食堂总消费 交通总消费 宿舍总消费 超市总消费 书类别  排名
  19.     '''  
  20.     data=[]
  21.     '''
  22.     读入成绩
  23.     '''
  24.     line = file_rank.readline()
  25.     line = file_rank.readline()#直接读取第二行数据 
  26.     while line:  
  27.         (seme,sid,rank,)=line.split('\t')
  28.         temp=[int(seme),int(sid),int(rank)]
  29.         data=data+[temp]
  30.         line = file_rank.readline()  
  31.         
  32.     i=1
  33.     while i<538:
  34.         temp=[3,i,-1]
  35.         data=data+[temp]
  36.         i=i+1
  37.             
  38.     '''
  39.     以学号为主key 学期为负key进行排序
  40.     '''
  41.     data=sorted(data,key=lambda x:(x[1],x[0]))
  42.     
  43.     '''
  44.     读入图书馆门禁次数(学期计)
  45.     '''
  46.     
  47.     '''
  48.     新增 月平均 月方差 月最大 月最小 
  49.          日平均  日方差 日最大 日最小
  50.         06-22 小时点次数
  51.         共 25 维
  52.     0    1    2    3    4567 891011      12-28 29-71
  53.     学期 学号 排名  总数 月   日          06-22  1-43
  54.     '''
  55.     line = file_library.readline()
  56.     line = file_library.readline()#直接读取第二行数据 
  57.     zero26=np.zeros(26,int).tolist();
  58.     i=0
  59.     while i<len(data):
  60.         data[i]=data[i]+zero26;
  61.         i=i+1
  62.     
  63.     data3=np.zeros(shape=(len(data),6,31)).tolist();#统计每天的次数 每个月取31天 
  64.     '''1/3学期 data3[index][0-4]表示 9-1月 9~0 10~1 11~2 12~3 1~4
  65.          2学期 data3[index][0-5]表示 2-7月
  66.     '''
  67.     n_1=5;#1 3 学期 5个月
  68.     n_2=6;# 2 学期 6个月
  69.     while line:
  70.         readtime=0#记录读取次数 第一次读学期 第二次为学号
  71.         (seme,sid,date,time,)=line.split('\t')
  72.         seme=int(seme);
  73.         sid=int(sid);
  74.         index=(sid-1)*3+seme-1;#第seme的第sid号学生在data中的下标号  
  75.         data[index][3]+=1;#学期签到总数
  76.         offset=6;#小时签到次数对应data列的偏移量
  77.         #统计小时签到次数
  78.         hour=int(time[0:2]);
  79.         data[index][hour+offset]+=1;
  80.         month=int(date[0:2]);
  81.     
  82.         day=int(date[2:])
  83.         if seme!=2:
  84.             data3[index][(month-9)%12][day-1]+=1;
  85.         else:
  86.             data3[index][month-2][day-1]+=1;
  87.         line = file_library.readline()
  88.         
  89.     '''
  90.     根据data2和data3求均值 最大 最小 方差 并写入到data里
  91.     '''    
  92.     i=0
  93.     while i<len(data):
  94.         if i%3==1:#是否为第二学期
  95.             n=n_2;
  96.         else:
  97.             n=n_1;
  98.         mmean=data[i][3]/n;
  99.         dmean=data[i][3]/(n*31);
  100.         m=np.zeros(n,int).tolist();#该人每个人的总数
  101.         d=np.zeros(n*31,int).tolist()#该人每天的总数
  102.         j=0#第j个月
  103.         l=0#该学期第l天
  104.         while j<n:
  105.             m[j]=int(sum(data3[i][j]))
  106.             k=0#第j月中的k天
  107.             while k<31:
  108.                 d[l]=int(data3[i][j][k])
  109.                 l=l+1
  110.                 k=k+1
  111.             j=j+1
  112.         mmax=max(m);
  113.         dmax=max(d);
  114.         mmin=min(m);
  115.         dmin=min(d);
  116.         mvar=np.var(m);
  117.         dvar=np.var(d);
  118.         data[i][4:12]=mmean,mvar,mmax,mmin,dmean,dvar,dmax,dmin;
  119.         i=i+1
  120.     '''
  121.     借书
  122.     '''
  123.     """
  124.     读取书籍信息
  125.     """
  126.     
  127.     BookInfo = dict()
  128.     BookClass = ['A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','TB','TD','TE','TF','TG','TH','TJ','TK','TL','TM','TN','TP','TQ','TS','TT','TU','TV','U','V','X','Y', 'Z','OO']
  129.     '''
  130.     pickle.dump(BookInfo,open('BookInfo.pkl','wb'))
  131.     '''
  132.     '''
  133.     with open('图书类别.txt', encoding = 'utf-8') as f:
  134.         f.readline();
  135.         for line in f:
  136.             line = line.replace('\n', '')
  137.             (BookNumber, bookclass) = line.split('\t');
  138.             if not BookNumber.isdigit():
  139.                 continue
  140.             
  141.             BookInfo[BookNumber] = bookclass
  142.     '''
  143.     '''
  144.     新增内容：
  145.     72 74 74 75     76 77 78 79
  146.     月总借书        日总借书
  147.     均值 方差 最大 最小
  148.     ☞统计各种类书之和
  149.     '''
  150.     data2=np.zeros(shape=(len(data),6,31)).tolist();#统计每个学期每个人 某月的第某天借了几本书
  151.     
  152.     BookInfo=pickle.load(open('BookInfo.pkl','rb'))
  153.     zero43=np.zeros(43,int).tolist()
  154.     i=0
  155.     offset=30 #书类别偏移
  156.     while i<len(data):
  157.         data[i]+=zero43
  158.         i=i+1
  159.     line=file_borrow.readline()
  160.     line=file_borrow.readline()
  161.     
  162.     while line:
  163.         (seme,sid,name,date,)=line.split('\t')
  164.         index=(int(sid)-1)*3+int(seme)-1
  165.         month=int(date[:2])
  166.         day=int(date[2:])
  167.         if int(seme)!=2:
  168.             data2[index][(month-9)%12][day-1]+=1;
  169.         else:
  170.             data2[index][month-2][day-1]+=1;
  171.         if name not in BookInfo.keys():
  172.             data[index][42+offset-1]+=1
  173.         else:
  174.             i=0
  175.             while i<len(BookClass)-1:
  176.                 if BookClass[i]==BookInfo[name]:
  177.                     break;
  178.                 i=i+1
  179.             data[index][i+offset-1]+=1
  180.         line=file_borrow.readline()
  181.     i=0
  182.     '''
  183.     计算月 日 放进 data
  184.     '''
  185.     zeros8=np.zeros(8,int).tolist();
  186.     while i<len(data):
  187.         data[i]+=zeros8
  188.         i=i+1
  189.     i=0
  190.     while i<len(data):
  191.         if i%3==1:
  192.             n=n_2
  193.         else:
  194.             n=n_1
  195.         num=sum(data[i][offset-1:])#某个人某学期总借书量
  196.         mmean=num/n;
  197.         dmean=num/(n*31);
  198.         m=np.zeros(n,int).tolist();
  199.         d=np.zeros(n*31,int).tolist();
  200.         j=0#第j个月
  201.         l=0#该学期第l天
  202.         while j<n:
  203.             m[j]=int(sum(data2[i][j]))
  204.             k=0#第j月中的k天
  205.             while k<31:
  206.                 d[l]=int(data2[i][j][k])
  207.                 l=l+1
  208.                 k=k+1
  209.             j=j+1
  210.         mmax=max(m);
  211.         dmax=max(d);
  212.         mmin=min(m);
  213.         dmin=min(d);
  214.         mvar=np.var(m);
  215.         dvar=np.var(d);
  216.         data[i][72:]=mmean,mvar,mmax,mmin,dmean,dvar,dmax,dmin;
  217.         i=i+1
  218.         
  219.     data = data[:273]
  220.     # 整理data
  221.     test_predata_x = []
  222.     for i in range(91):
  223.         tmp = [data[i * 3][2], data[i * 3 + 1][2]] + [data[i * 3][1]] + data[i * 3][3:] + data[i * 3 + 1][3:] + \
  224.             data[i * 3 + 2][3:]
  225.         
  226.         test_predata_x.append(tmp)
  227.     
  228.     # 整理输出结果
  229.     test_y = []
  230.     with open('sample_submission.csv', 'r') as f:
  231.         lines = f.readlines()
  232.         for line in lines[1:]:
  233.             line.replace('\n', '')
  234.             test_y.append(int(line.split(',')[1]))
  235.         
  236.     
  237.     ''' 学期、学号、排名、门禁、书籍信息 '''
  238.     #pickle.dump(data, open('data_pre.pkl', 'wb'))
  239.     
  240.     return test_predata_x, test_y

pre_treat.py:

  1. # -*- coding: utf-8 -*-
  2. """
  3. Created on Mon May  7 13:28:12 2018
  5. @author: Type真是太帅了
  6. """
  7. import numpy as np
  8. import pickle
  9.  
  10. def pre_train():
  11.     file_rank=open('成绩.txt','r')
  12.     file_library=open('图书馆门禁.txt','r')
  13.     file_borrow=open('借书.txt','r')
  14.     file_consume=open('消费.txt','r')
  15.     #file_type=open('图书类别.txt','r')
  16.     
  17.     '''
  18.      学期 学号 图书馆门禁次数 食堂总消费 交通总消费 宿舍总消费 超市总消费 书类别  排名
  19.     '''  
  20.     data=[]
  21.     '''
  22.     读入成绩
  23.     '''
  24.     line = file_rank.readline()
  25.     line = file_rank.readline()#直接读取第二行数据 
  26.     while line:  
  27.         temp=[]
  28.         pre=0
  29.         while pre<len(line)-2: #对于每行line的每个字符 将其转化为数字形式并存储于数组中 最后\n两个字符不读
  30.             if line[pre]!='\t':
  31.                 end=pre+1
  32.                 while end<len(line)-1:
  33.                     if line[end]=='\t':
  34.                         temp=temp+[int(line[pre:end])]
  35.                         pre=end+1
  36.                         break
  37.                     else:
  38.                         end=end+1
  39.             else:
  40.                 pre=pre+1
  41.                 end=pre+1
  42.         data=data+[temp]
  43.         line = file_rank.readline()  
  44.     '''
  45.     以学号为主key 学期为负key进行排序
  46.     '''
  47.     data=sorted(data,key=lambda x:(x[1],x[0]))
  48.     
  49.     '''
  50.     读入图书馆门禁次数(学期计)
  51.     '''
  52.     
  53.     '''
  54.     新增 月平均 月方差 月最大 月最小 
  55.          日平均  日方差 日最大 日最小
  56.         06-22 小时点次数
  57.         共 25 维
  58.     0    1    2    3    4567 891011      12-28 29-71
  59.     学期 学号 排名  总数 月   日          06-22  1-43
  60.     '''
  61.     line = file_library.readline()
  62.     line = file_library.readline()#直接读取第二行数据 
  63.     zero26=np.zeros(26,int).tolist();
  64.     i=0
  65.     while i<len(data):
  66.         data[i]=data[i]+zero26;
  67.         i=i+1
  68.     
  69.     data3=np.zeros(shape=(len(data),6,31)).tolist();#统计每天的次数 每个月取31天 
  70.     '''1/3学期 data3[index][0-4]表示 9-1月 9~0 10~1 11~2 12~3 1~4
  71.          2学期 data3[index][0-5]表示 2-7月
  72.     '''
  73.     n_1=5;#1 3 学期 5个月
  74.     n_2=6;# 2 学期 6个月
  75.     while line:
  76.         readtime=0#记录读取次数 第一次读学期 第二次为学号
  77.         (seme,sid,date,time,ent)=line.split('\t')
  78.         seme=int(seme);
  79.         sid=int(sid);
  80.         index=(sid-1)*3+seme-1;#第seme的第sid号学生在data中的下标号  
  81.         data[index][3]+=1;#学期签到总数
  82.         offset=6;#小时签到次数对应data列的偏移量
  83.         #统计小时签到次数
  84.         hour=int(time[0:2]);
  85.         data[index][hour+offset]+=1;
  86.         month=int(date[0:2]);
  87.     
  88.         day=int(date[2:])
  89.         if seme!=2:
  90.             data3[index][(month-9)%12][day-1]+=1;
  91.         else:
  92.             data3[index][month-2][day-1]+=1;
  93.         line = file_library.readline()
  94.         
  95.     '''
  96.     根据data2和data3求均值 最大 最小 方差 并写入到data里
  97.     '''    
  98.     i=0
  99.     while i<len(data):
  100.         if i%3==1:#是否为第二学期
  101.             n=n_2;
  102.         else:
  103.             n=n_1;
  104.         mmean=data[i][3]/n;
  105.         dmean=data[i][3]/(n*31);
  106.         m=np.zeros(n,int).tolist();#该人每个人的总数
  107.         d=np.zeros(n*31,int).tolist()#该人每天的总数
  108.         j=0#第j个月
  109.         l=0#该学期第l天
  110.         while j<n:
  111.             m[j]=int(sum(data3[i][j]))
  112.             k=0#第j月中的k天
  113.             while k<31:
  114.                 d[l]=int(data3[i][j][k])
  115.                 l=l+1
  116.                 k=k+1
  117.             j=j+1
  118.         mmax=max(m);
  119.         dmax=max(d);
  120.         mmin=min(m);
  121.         dmin=min(d);
  122.         mvar=np.var(m);
  123.         dvar=np.var(d);
  124.         data[i][4:12]=mmean,mvar,mmax,mmin,dmean,dvar,dmax,dmin;
  125.         i=i+1
  126.     '''
  127.     借书
  128.     '''
  129.     """
  130.     读取书籍信息
  131.     """
  132.     
  133.     BookInfo = dict()
  134.     BookClass = ['A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','TB','TD','TE','TF','TG','TH','TJ','TK','TL','TM','TN','TP','TQ','TS','TT','TU','TV','U','V','X','Y', 'Z','OO']
  135.     '''
  136.     pickle.dump(BookInfo,open('BookInfo.pkl','wb'))
  137.     '''
  138.     '''
  139.     with open('图书类别.txt', encoding = 'utf-8') as f:
  140.         f.readline();
  141.         for line in f:
  142.             line = line.replace('\n', '')
  143.             (BookNumber, bookclass) = line.split('\t');
  144.             if not BookNumber.isdigit():
  145.                 continue
  146.             
  147.             BookInfo[BookNumber] = bookclass
  148.     '''
  149.     '''
  150.     新增内容：
  151.     72 74 74 75     76 77 78 79
  152.     月总借书        日总借书
  153.     均值 方差 最大 最小
  154.     ☞统计各种类书之和
  155.     '''
  156.     data2=np.zeros(shape=(len(data),6,31)).tolist();#统计每个学期每个人 某月的第某天借了几本书
  157.     
  158.     BookInfo=pickle.load(open('BookInfo.pkl','rb'))
  159.     zero43=np.zeros(43,int).tolist()
  160.     i=0
  161.     offset=30 #书类别偏移
  162.     while i<len(data):
  163.         data[i]+=zero43
  164.         i=i+1
  165.     line=file_borrow.readline()
  166.     line=file_borrow.readline()
  167.     
  168.     while line:
  169.         (seme,sid,name,date,ent)=line.split('\t')
  170.         index=(int(sid)-1)*3+int(seme)-1
  171.         month=int(date[:2])
  172.         day=int(date[2:])
  173.         if int(seme)!=2:
  174.             data2[index][(month-9)%12][day-1]+=1;
  175.         else:
  176.             data2[index][month-2][day-1]+=1;
  177.         if name not in BookInfo.keys():
  178.             data[index][42+offset-1]+=1
  179.         else:
  180.             i=0
  181.             while i<len(BookClass)-1:
  182.                 if BookClass[i]==BookInfo[name]:
  183.                     break;
  184.                 i=i+1
  185.             data[index][i+offset-1]+=1
  186.         line=file_borrow.readline()
  187.     i=0
  188.     '''
  189.     计算月 日 放进 data
  190.     '''
  191.     zeros8=np.zeros(8,int).tolist();
  192.     while i<len(data):
  193.         data[i]+=zeros8
  194.         i=i+1
  195.     i=0
  196.     while i<len(data):
  197.         if i%3==1:
  198.             n=n_2
  199.         else:
  200.             n=n_1
  201.         num=sum(data[i][offset-1:])#某个人某学期总借书量
  202.         mmean=num/n;
  203.         dmean=num/(n*31);
  204.         m=np.zeros(n,int).tolist();
  205.         d=np.zeros(n*31,int).tolist();
  206.         j=0#第j个月
  207.         l=0#该学期第l天
  208.         while j<n:
  209.             m[j]=int(sum(data2[i][j]))
  210.             k=0#第j月中的k天
  211.             while k<31:
  212.                 d[l]=int(data2[i][j][k])
  213.                 l=l+1
  214.                 k=k+1
  215.             j=j+1
  216.         mmax=max(m);
  217.         dmax=max(d);
  218.         mmin=min(m);
  219.         dmin=min(d);
  220.         mvar=np.var(m);
  221.         dvar=np.var(d);
  222.         data[i][72:]=mmean,mvar,mmax,mmin,dmean,dvar,dmax,dmin;
  223.         i=i+1
  224.     
  225.     # 整理data
  226.     train_predata_x = []
  227.     train_y = []
  228.     for i in range(538):
  229.         tmp = [data[i * 3][2], data[i * 3 + 1][2]] + [data[i * 3][1]] + data[i * 3][3:] + data[i * 3 + 1][3:] + \
  230.             data[i * 3 + 2][3:]
  231.         
  232.         train_predata_x.append(tmp)
  233.         train_y.append(data[i * 3 + 2][2])
  234.     # =============================================================================
  235.     #     if item[0] == 3:
  236.     #         train_y.append(item[2])
  237.     #     if item[1] == pre_stu_id:
  238.     #         stu_info.extend(item[2:])
  239.     #     else:
  240.     #         data_zhengli.append(stu_info)
  241.     #         stu_info = item[1:]
  242.     #         pre_stu_id = item[1]
  243.     # =============================================================================
  244.     
  245.            
  246.         
  247.     ''' 学期、学号、排名、门禁、书籍信息 '''
  248.     #pickle.dump(data, open('data_pre.pkl', 'wb'))
  249.     #pickle.dump(train_predata_x, open('train_predata_x.pkl', 'wb'))
  250.     
  251.     return train_predata_x, train_y
  252.  
  253.  
  254.  
  255.

结果：

改进前（没有使用月平均最大最小方差等信息）

优化后：(317维)

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/人工智能uu/article/detail/815725
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号