首先观看数据：
l 数据的基本特征用 describe 描述每个基本特征
l 画图画出每个特征的基本统计图
应用importmatplotlib.pylab aspl 画图显示
l 关于特征值特别大的数据集 ；可能对结果产生权重的等级影响 所以尽量将数据进行归一化 特征值归一化的原因：
1；看数据范围看看是否可以归一化
Aum 归一化 虽然等级已经有过归一化这个方向；
l ：看看数据是否完整() 想到对后续目标的完整度处理
由于一般的模型对于空值来讲不符合模型的，所以对于模型一般进行将空值赋值为-1
data_all=data_all.fillna("-1")
l 数据清洗：由于数据有一些是不在
l 思考具体问题 应用具体场景进行思考什么样的场景和流程 会导致这样的结果
找到对应与之相关的因素
有时候感觉有用的特征却没有用，但是感觉没用的特征却对结果产生了重要作用
l 处理数据：
重点数据
处理思想：即归一化：由于邮编没有相同的 所以 相似性不高，所以应该对邮编进行分类和相似度处理
分类：根据一线二线三线城市划分等级；ZIP
l 1：邮编
进行相似度处理
前两位表示省(直辖市、自治区)，第三位代表邮区，
第四位代表县(市)，最后两位：即投递区的位置。
一线 北京100000，上海200000，广州 500000 1
1南京 2武汉 3沈阳 4西安 5成都 6重庆 7杭州8青岛 9大连 10宁波
二线：天津300000，重庆404100，杭州310000，青岛 266000，大连116000，宁波315000， 2
其他： 3
将邮编进行一线二线三线城市进行分类
l 应用很多地理位置的特征进行审阅
四个关于地理位置的特征：则找到一种权重关系和数据处理将数据进行正规化和处理问题的标准
Crm ：地理位置
邮编： 省份：
l 资金的处理：
根据AUM 判断 和 资金评判进行的资金的划分
判断何种处理对数据集的影响较大：
特征训练和提取：
将数据处理之后的特征进行特征比重性分析
分析哪种特征比较对结果造成好的结果
由图可知：相关性最大的是投资状态，
强关联性不大的删除 性别： 婚姻状况：职业 因为都是空值；最高学历
其实删除的这些数据由于数据不是必填所以此数据就不能作为结果的预测量
为什么不想在宜信呆着了？
因为现在这个团队就我自己在做这个挖掘，我也通过我自己的努力和摸索慢慢前进，但是我这样感觉自己成长的很慢了，
有的时候他的数据好多都不是必填所以其实这个数据字段对结果可能产生很大的影响，但是由于数据的不完整性，就让我不能应用这个字段，所以可能会对我的预测结果产生很大影响
#-*- coding: UTF-8 -*-
import math
import random
import gettext
from sklearn.datasets import load_iris
from sklearn.ensemble import RandomForestClassifier
import pandas as pd
import numpy as np
import statsmodels.api as sm
import matplotlib.pylab as pl
import numpy as np
from statsmodels.sandbox.regression.predstd import wls_prediction_std
from collections import defaultdict
import copy
import codecs
import sys
import time
from threading import Thread
from threading import Lock
import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_classification
from sklearn.ensemble import ExtraTreesClassifier
type = sys.getfilesystemencoding()
"""
=========================================
Feature importances with forests of trees
=========================================
This examples shows the use of forests of trees to evaluate the importance of
features on an artificial classification task. The red bars are the feature
importances of the forest, along with their inter-trees variability.
As expected, the plot suggests that 3 features are informative, while the
remaining are not.
"""
#读取数据并且将空格的地方填写值
print(__doc__)
data_all=pd.read_csv("E://ease-job//work//job//data.csv",)
data_all=data_all.fillna("-1")
"""
def __init__(self, userData, k):
self.userData = userData
self.k = k
def simPearson(self, user1, user2):
data = self.userData
sim = {}
for item in data[user1]:
if item in data[user2]:
sim[item] = 1
n = len(sim)
if not n:
return -1
sum1 = sum([data[user1][item] for item in sim])
sum2 = sum([data[user2][item] for item in sim])
sum1Sq = sum([math.pow(data[user1][item], 2) for item in sim])
sum2Sq = sum([math.pow(data[user2][item], 2) for item in sim])
sumMulti = sum([data[user1][item] * data[user2][item] for item in sim])
num1 = sumMulti - sum1 * sum2/n
num2 = math.sqrt((sum1Sq - math.pow(sum1, 2)/n) * (sum2Sq - math.pow(sum2, 2)/n))
if not num2:
return -1
return 0.5 + 0.5 * (num1 / num2) # 将皮尔逊相似度转换至[0, 1]
def kNeibors(self, theUserID, k):
data = self.userData
similarities = [(otherID, self.simPearson(theUserID, otherID)) for otherID in data if otherID != theUserID]
similarities.sort(key=lambda x: x[1], reverse=True)
return similarities[0 : k]
def estimatePref(self, theUserID, theItemID, simUsers=None):
data = self.userData
try:
truePref = data[theUserID][theItemID]
except KeyError:
truePref = 0
if truePref:
return truePref
total = 0.0
simSum = 0.0
simUsers = simUsers or self.kNeibors(theUserID, self.k)
for otherID, sim in simUsers:
if sim <= 0: continue
try:
otherTruePref = data[otherID][theItemID]
except KeyError:
continue
total += otherTruePref * sim
simSum += sim
if not simSum:
return -1 #标记出错
return total / simSum
def recommend(self, theUserID, howMany):
data = self.userData
kNeighbors = self.kNeibors(theUserID, self.k)
ranks = []
for otherID, in kNeighbors:
tempRanks = [(itemID, self.estimatePref(theUserID, itemID, kNeighbors)) for itemID in data[otherID] if itemID not in data[theUserID]]
ranks.extend(tempRanks)
ranks.sort(key=lambda x: x[1])
return ranks[: -(howMany+1): -1]
class Evaluator:
def __init__(self):
self.diSum = 0.0
self.count = 0
self.lock = Lock()
def evaluate(self, data, testPercentage):
self.data = data
self.testPercentage = testPercentage
startTime = time.clock()
testPercentage = testPercentage or self.testPercentage
trainData, testData = self.splitData(self.data, self.testPercentage)
self.recommender = UserBased(trainData, 10)
part1Data, part2Data, part3Data = self.splitTestDataTo3Parts(testData)
#开3个线程计算RMSE值
t1 = Thread(target=self.doEvaluate, args=(trainData, part1Data))
t2 = Thread(target=self.doEvaluate, args=(trainData, part2Data))
t3 = Thread(target=self.doEvaluate, args=(trainData, part3Data))
t1.start()
t2.start()
t3.start()
t1.join()
t2.join()
t3.join()
result = math.sqrt(self.diSum / self.count)
print '计算RMSE结束, RMSE值为: %s; 用时: %s 秒' % (result, time.clock() - startTime)
return result
def splitData(self, data=None, testPercentage=None):
data = data or self.data
testPerc = testPercentage or self.testPercentage
trainData = {}
testData = {}
for user in data:
for item, score in data[user].items():
if random.random() < testPerc:
testData.setdefault(user, {})
testData[user][item] = score
else:
trainData.setdefault(user, {})
trainData[user][item] = score
return trainData, testData
def splitTestDataTo3Parts(self, testData):
part1Data = {}
part2Data = {}
part3Data = {}
for user in testData:
x = random.random()
if x < 0.3:
part1Data[user] = testData[user]
elif x < 0.6:
part2Data[user] = testData[user]
else:
part3Data[user] = testData[user]
return part1Data, part2Data, part3Data
def doEvaluate(self, trainData, partTestData):
partDiSum = 0.0
partCount = 0
recommender = self.recommender
k = recommender.k
for user in partTestData:
simUsers = recommender.kNeibors(user, k)
for item, score in partTestData[user].items():
predictPref = recommender.estimatePref(user, item, simUsers)
if predictPref < 0: continue
partDiSum += math.pow(predictPref - score, 2)
partCount += 1
self.lock.acquire()
self.diSum += partDiSum
self.count += partCount
self.lock.release()
def loadData(filename):
startTime = time.clock()
totalData = {}
count = 0
for line in open(filename):
userID, itemID, score,_ = line.split(',')
user, item, score = int(userID), int(itemID), int(score)
totalData.setdefault(user, {})
totalData[user][item] = score
count += 1
print '数据加载成功! 用时: %s秒 总记录: %s 行,用户数: %s'%(time.clock()-startTime, count, len(totalData))
return totalData
"""
#######################################################################################
#数据字符型数据处理 和数据归一化将数据处理为合适的的数据
def changetargetdata(data_all):
f1 = open("E://ease-job//work//job//data.csv",'r')
f2 = open("E://ease-job//work//job//data1.csv",'w')
f3 = open("E://ease-job//work//job//data2.csv",'w')
f4 = open("E://ease-job//work//job//data3.csv",'w')
result1 = defaultdict(list)
result2 = defaultdict(list)
result3 = defaultdict(list)
for line in f1.readlines():
line = line.strip()
z,q,x,c,v,b,n,m,l,j,h,g,f,d,s,d,y,u,i,o,p,chunk,k,qq,ww,ee,rr,tt,yy=line.split(",",29)
if u=='"M2"':
result3='1'
f4.writelines(result3+'\n')
elif u=='"M1"':
result3='2'
f4.writelines(result3+'\n')
elif u=='"V"':
result3='3'
f4.writelines(result3+'\n')
elif u=='"SV"':
result3='4'
f4.writelines(result3+'\n')
elif u=='"P"':
result3='5'
f4.writelines(result3+'\n')
elif u=='"CLIENTLEVELE"':
f4.writelines("CLIENTLEVELE"+'\n')
else:
f4.writelines('0'+'\n')
if f[1:3]=="10" or f[1:3]=="20" or f[1:3]=="50" or f[1:3]=="30":
result2='1'
f3.writelines(result2+'\n')
elif f[1:4]=="404" or f[1:4]=="310" or f[1:4]=="266" or f[1:4]=="116" or f[1:4]=="315":
result2='2'
f3.writelines(result2+'\n')
elif f =='"ZIP"':
f3.writelines("ZIP"+'\n')
else:
result2='3'
f3.writelines(result2+'\n')
if chunk== '"月息通"':
result1='1'
f2.writelines(result1+'\n')
elif chunk=='"月满盈"':
result1 = '2'
f2.writelines(result1+'\n')
elif chunk=='"宜信宝"':
result1='3'
f2.writelines(result1+'\n')
elif chunk=='"双季风"':
result1 = '4'
f2.writelines(result1+'\n')
elif chunk=='"季度丰"':
result1 = '5'
f2.writelines(result1+'\n')
elif chunk=='"玖玖盈"':
result1 = '6'
f2.writelines(result1+'\n')
elif chunk=='"PRODUCT_NAME"':
f2.writelines('PRODUCT_NAME'+'\n')
else:
f2.writelines('0'+'\n')
f2.close()
f3.close()
f4.close()
admit=pd.read_csv("E://ease-job//work//job//data1.csv")
zip=pd.read_csv("E://ease-job//work//job//data2.csv")
CLIENTLEVELE=pd.read_csv("E://ease-job//work//job//data3.csv")
data_all['ZIP1']=zip['ZIP']
data_all['CLIENTLEVELE1']=CLIENTLEVELE['CLIENTLEVELE']
data_all['admit']=admit['PRODUCT_NAME']
return data_all
data=changetargetdata(data_all)
dataset = pd.DataFrame(data, columns=['FHIGHEST_EDUCATION','CLIENTLEVELE','"FSEX"','AUM','FCITY','FINVEST_STATUS','ZIP1','FTRADE','RESOURE','FRANK','CLIENTLEVELE1','FANNUAL','LENDERID','admit'])
dataset.to_csv("E://ease-job//work//job//datast.csv")
def feature_importances(dataset):
X=dataset.iloc[:,0:11]
y=dataset['admit']
########### 预测特征+结果显示
forest = ExtraTreesClassifier(n_estimators=250,
random_state=0)
z=forest.fit(X, y)
importances = forest.feature_importances_
std = np.std([tree.feature_importances_ for tree in forest.estimators_],
axis=0)
indices = np.argsort(importances)[::-1]
# Print the feature ranking
print("Feature ranking:")
feature_list=[]
for f in range(11):
print("%d. feature %d (%f)" % (f + 1, indices[f], importances[indices[f]]))
feature_list.append([indices[f],importances[indices[f]]])
feature_list.sort(reverse=True)
print(feature_list)
# Plot the feature importances of the forest
plt.figure()
plt.title("Feature importances")
plt.bar(range(11), importances[indices],
color="r", yerr=std[indices], align="center")
plt.xticks(range(11), indices)
plt.xlim([-1, 11])
plt.show()
#########################################
#随机森林分类 输出随机森林分类的结果和方式
def RandomForestClassifie(dataset):
print("#############随机森林分类###################")
df = pd.DataFrame(dataset, columns=['FINVEST_STATUS','AUM','ZIP1','FTRADE','RESOURE','FRANK','FCITY','FANNUAL','CLIENTLEVELE1'])
df['species'] = dataset['admit']
########## 数据集的划分 随机划分
df['is_train'] = np.random.uniform(0, 1, len(data)) <= .75
train, test = df[df['is_train']==True], df[df['is_train']==False]
features = df.columns[:8]
clf = RandomForestClassifier(n_jobs=2)
y, _ = pd.factorize(train['species'])
clf.fit(train[features], y)
for j in df.columns[3:4]:
featureSet=set(df["%s"%j].drop_duplicates())
preds = [clf.predict(test[features])]
c=pd.crosstab(test['species'], preds, rownames=['actual'], colnames=['preds'])
print(c)
return c
#########################################################################################
#AHP 权重的赋值
#########################################################################################
#分集： ########## 数据集的划分 随机划分
#输入处理之后的数据data
#输出：随机分类的训练集和测试集
def SplitData(data):
#print("##############将数据分为训练集和测试集##############################")
data['is_train'] = np.random.uniform(0, 1, len(data)) <= .75
train, test = data[data['is_train']==True], data[data['is_train']==False]
return train,test
#
# 解压rating信息，格式：用户id\t硬盘id\t用户rating\t时间
# 输入：数据集合
# 输出:已经解压的排名信息
############################################
#读取文件 将open训练集的train集合
#输出： 【train的user，item，对应一个特征的选项】train的user
def getRatingInformation(test_contents):
rates=[]
user_dic=[]
for line in test_contents:
line =line.strip()
number,u,items,scores= line.split(",",4)
rates.append([u,items,scores]) #append是list(列表)的方法，函数参数是可以是任意一个元素，作用是在列表的最后添加上这个新元素
user_dic.append([u])
return rates,user_dic
#
# 生成用户评分的数据结构
#
# 输入:所以数据 [[2,1,5],[2,4,2]...]
# 输出:1.用户打分字典 2.产片字典
# 使用字典，key是用户id，value是用户对产片的评价，
# rate_dic[2]=[(1,5),(4,2)].... 表示用户2对产片1的评分是5，对产片4的评分是2
#格式化成字典数据
#将数据分类
# 1.用户字典test_dic：dic[用户id]=[(产品id,行为评分)...]
# 2.产片字典 test_item_to_user：dic产品id]=[用户id1,用户id2...]
def createUserRankDic(rates):
#print("###############将数据转变为两个list############################")
user_rate_dic={
}
item_to_user={
}
for i in rates: #i是数组的意思
#print(rates)
user_rank=(i[1],i[2])
if i[0] in user_rate_dic:
user_rate_dic[i[0]].append(user_rank) #用户打分字典
else:
user_rate_dic[i[0]]=[user_rank]
if i[1] in item_to_user:
item_to_user[i[1]].append(i[0]) #产片字典
else:
item_to_user[i[1]]=[i[0]]
return user_rate_dic,item_to_user
def calcCosDistSpe(user1,user2):
avg_x=0.0
avg_y=0.0
for key in user1:
avg_x+=key[1]
avg_x=avg_x/len(user1)
for key in user2:
avg_y+=key[1]
avg_y=avg_y/len(user2)
u1_u2=0.0
for key1 in user1:
for key2 in user2:
if key1[1] > avg_x and key2[1]>avg_y and key1[0]==key2[0]:
u1_u2+=1
u1u2=len(user1)*len(user2)*1.0
sx_sy=u1_u2/math.sqrt(u1u2)
return sx_sy
#
#计算余弦距离
#
#
def calcCosDist(user1,user2): #余弦相似度
sum_x=0.0
sum_y=0.0
sum_xy=0.0
for key1 in user1:
for key2 in user2:
if key1[0]==key2[0] :
sum_xy+=key1[1]*key2[1]
sum_y+=key2[1]*key2[1]
sum_x+=key1[1]*key1[1]
if sum_xy == 0.0 :
return 0
sx_sy=math.sqrt(sum_x*sum_y)
return sum_xy/sx_sy
#
# 相似余弦距离
#
#
#
def calcSimlaryCosDist(user1,user2):
sum_x=0.0
sum_y=0.0
sum_xy=0.0
avg_x=0.0
avg_y=0.0
########key :找到userid对应的[产品和行为评分]
####### 求得user1和user2的 d的行为评分的平均值
"""
for key in user1:
avg_x+=int(key[1])
avg_x=avg_x/len(user1)
for key in user2:
avg_y+=int(key[1])
avg_y=avg_y/len(user2)
"""
for key1 in user1:
for key2 in user2:
if int(key1[0])==int(key2[0]) : #key[1]代表分数，key[0]代表产品名称
sum_xy+=(int(key1[1]))*(int(key2[1]))
sum_y+=(int(key2[1]))*(int(key2[1]))
sum_x+=(int(key1[1]))*(int(key1[1]))
if sum_xy == 0.0 :
return 0
sx_sy=math.sqrt(sum_x*sum_y)
if sx_sy==0:
return 0
return sum_xy/sx_sy
#
# 计算与指定用户最相近的邻居
# 输入:指定用户ID，输入用户数据，输入物品数据
# 输出:与指定用户最相邻的邻居列表
#
def calcNearestNeighbor(userid,users_dic,item_dic):
neighbors=[]
neighbors.append(userid)
for item in users_dic[userid]:
for neighbor in item_dic[item[0]]: #找出score为相同的项，并将用户认定为邻居，产片到用户的反差表，也就是与目标用户有过相同产品的用户
if neighbor != userid and neighbor not in neighbors:
neighbors.append(neighbor)
####neighbors为给出的user对应买的物品 物品对应的用户的集合
neighbors_dist=[]
####按行读取neighbors ,判断user与之的相似性
for neighbor in neighbors:
#print(users_dic[neighbor])
dist=calcSimlaryCosDist(users_dic[userid],users_dic[neighbor]) #calcSimlaryCosDist calcCosDist calcCosDistSpe
neighbors_dist.append([dist,neighbor])
neighbors_dist.sort(reverse=True) #输出最相邻的邻居列表
return neighbors_dist
def recommendByUserFC(test_contents,userid,k=10):
test_rates,user_dic=getRatingInformation(test_contents)
#格式化成字典数据
#将数据分类
# 1.用户字典test_dic：dic[用户id]=[(产品id,行为评分)...]
# 2.产片字典 test_item_to_user：dic产品id]=[用户id1,用户id2...]
test_dic,test_item_to_user=createUserRankDic(test_rates)
#寻找邻居
#寻找到邻居后，如果邻居看过的产片不在recommend_dic列表里，则添加，并认为该邻居的评分赋予给该产片，若多个邻居看过，
# 则该产片的评分是多位邻居的评分之和，为排除目标用户已经看过的产片
neighbors=calcNearestNeighbor(userid,test_dic,test_item_to_user)[:k]
user_product = [ i[0] for i in test_dic[userid]] #i[0]对应了目标用户买过的产品
recommend_dic={}
for neighbor in neighbors:
neighbor_user_id=neighbor[1] #neighbors包含([dist,neighbor])列表，所以neighbor[1]表示的是用户id
product=test_dic[neighbor_user_id] #返回的是[产品，评分]对
for movie in product:
if movie[0] not in recommend_dic: #movie[0]返回的是所有的产片
#print(recommend_dic[movie[0]])
recommend_dic[movie[0]]=movie[1]
#print(recommend_dic[movie[0]])
#neighbor[0]表示相似度
else:
recommend_dic[movie[0]]=int(recommend_dic[movie[0]])+int(movie[1]) #产片：评分1+评分2+.。。。
#print(recommend_dic[movie[0]])
#print len(recommend_dic)
#建立推荐列表
recommend_list=[]
key1=[]
#print(recommend_dic)
for key in recommend_dic: #key是产品名字
#print key
if key not in key1:
key1.append(key)
recommend_list.append([recommend_dic[key],key])
recommend_list.sort(reverse=True)
#print("#################################返回推荐产品列表[评分+产品]")
#print(recommend_list)
return recommend_list,key1,user_dic
#print("##################################输出目标用户的喜欢的产片")
#print(user_product)
#print("################################# 目标用户产片列表 即目标用户对应买的产品 则这个产品都有谁买")
#print(test_item_to_user)
#print("################################# 目标用户的邻居列表[相似度+用户]")
#print(neighbors)
#return recommend_list,user_product,test_item_to_user,neighbors #返回推荐产片列表，目标用户产片列表，产片字典，和邻居列表
####
#将产品的每个属性和特征生成的相似度列表在进行合并
def merge(list1,key1,set1,score_item_dic,score_item_list):
score_item_list=[]
for i in key1:
for j in list1:
if j[1]==i:
if i not in set1: #movie[0]返回的是所有的产片
score_item_dic[i]=j[0]
#print(score_item_dic[i])
else:
score_item_dic[i[0]]=int(score_item_dic[i[0]])+int(j[0]) #产片：评分1+评分2+.。。。
score_item_list.append([score_item_dic[i],i])
score_item_list.sort(reverse=True)
#print(score_item_list)
return score_item_dic,score_item_list
########################################
#输入之前的三个月的训练集， 和对应每个用户id
#中间通过循环遍历每一列，
#输出
def find(train,userid1):
set1={}
score_item_dic={}
score_item_list=[]
for i in range(6):
(pd.DataFrame(train, columns=[ 'LENDERID','admit']).join(train.icol(i+2))).to_csv("E://ease-job//work//job//train.csv")
test_contents=open("E://ease-job//work//job//train.csv")
#m=pd.read_csv("E://ease-job//work//job//train.csv")
#print(m.head())
list1,key1,user_dic=recommendByUserFC(test_contents,userid1)
score_item_dic,score_item_list=merge(list1,key1,set1,score_item_dic,score_item_list)
set1=set(key1)
return score_item_list ,set1,user_dic
#输出每个特征的【推荐产品，评分】，推荐产品种类
#文件数据格式化成二维数组 List[[用户id,产品id,产品行为评分]...
###################################
#画图
def fighter(score_item_list,set1):
plt.figure()
plt.title("score_item_list chance")
length=len(set1)
plt.bar( range(length),
color="r", yerr=std[indices], align="center")
plt.xticks(range(11), indices)
plt.xlim([-1, length])
plt.show()
######################################
#输入：[此产品的数量，产品的种类]
#输出：【次产品的选择概率，产品的种类】
def probability(score_item_list):
print(score_item_list)
probabilit=[]
sum1=0
for j in score_item_list:
sum1+=int(j[0])
for i in score_item_list:
if isinstance(i[0],int):
probabilit.append([(i[0]*1.0/sum1),i[1]])
else:
print( "Error")
print(i[0])
"""
print("################ 最终推荐列表[推荐这个产品的的比例，对应产品]##############################")
print("'月息通' -- '1'")
print("'月满盈' -- '2'")
print("'宜信宝' -- '3'")
print("'双季风' -- '4'")
print("'季度丰' -- '5'")
print("'玖玖盈' -- '6'")
"""
print(probabilit)
#######################################
#输入 ：测试集test
# 输出 ：获取新用户的各种集合
def testdatachange(test):
#print("##################将数据变为list###################################")
test.to_csv("E://ease-job//work//job//testchange.csv")
test=open("E://ease-job//work//job//testchange.csv")
rates=[]
Admit=[]
for line in test:
line =line.strip()
number,FINVEST_STATUS,ZIP1,FTRADE,RESOURE,FRANK,CLIENTLEVELE1,FANNUAL,LENDERID,admit= line.split(",",10)
rates.append([FINVEST_STATUS,ZIP1,FTRADE,RESOURE,FRANK,CLIENTLEVELE1,FANNUAL,LENDERID,admit]) #append是list(列表)的方法，函数参数是可以是任意一个元素，作用是在列表的最后添加上这个新元素
Admit.append([admit])
return rates,Admit
##############################
# 输入：open形式的读取文件 保证输入为number,u,items 分别转化为list格式
#得到训练集 train 的 user集合
def getuser_dic(test_contents):
user_dic=[]
for line in test_contents:
line =line.strip()
number,u,items= line.split(",",3)
user_dic.append(u)
return user_dic
################################################
#主函数的判断用户的分类 1：老用户(在之前3个月时间内出现买过产品的客户， 2：新用户(买过产品的新用户 ，未买过产品的新用户 ))
#直接print 对应的产品和评分
def judge(ranks):
#print(ranks)
test_contents=open("E://ease-job//work//job//train.csv")
user_dic1=getuser_dic(test_contents)
#print(user_dic1)
for i in ranks:
if i[7] in user_dic1: #当测试集的用户在训练集中则直接找到最邻近的用户即可
if i[7]!='LENDERID':
score_item_list,set1,user_dic=find(train,'392573')
probability(score_item_list)
else:
print(i[7])
##################################################################################
#数据处理将train 和test 变为list格式
def get_dic(data1):
data1.to_csv("E://ease-job//work//job//linshi.csv")
data1=open("E://ease-job//work//job//linshi.csv")
dic=[]
for line in data1:
line =line.strip()
number,FHIGHEST_EDUCATION,CLIENTLEVELE,FSEX,AUM,FCITY,FINVEST_STATUS,ZIP1,FTRADE,RESOURE,FRANK,CLIENTLEVELE1,FANNUAL,LENDERID,admit,is_train= line.split(",",16)
dic.append([FCITY,FHIGHEST_EDUCATION,CLIENTLEVELE,FSEX,FINVEST_STATUS,ZIP1,FTRADE,RESOURE,FRANK,CLIENTLEVELE1,FANNUAL,LENDERID,admit])
return dic
def newcustomer (train_dic,i):
max_score=0
scorer=[]
item=[]
user=[]
length=len(test_dic[0])
for j in train_dic:
print(j)
score=0
for m in range(length-2):
if j[m]==i[m] and j[12]!='0':
score+=1
scorer.append(score)
if max_score
max_score=score
print(max_score)
#print(scorer)
num=0
for m in train_dic:
if scorer[num]==max_score or scorer[num]==max_score-1:
if m[11] not in user:
user.append(m[11])
item.append(m[12])
num+=1
return (user),(item)
def probabiliter(item):
set1=list(set(item))
probab=[]
sum1=0
for j in item:
sum1+=1
for sm in set1:
set_number=0
for i in item:
if i==sm:
set_number+=1
probab.append([sm,set_number*1.0/sum1])
return probab
#主程序
#输入 ： 测试数据集合
if __name__ == '__main__':
##########dataset 即为原来的主要数据 对这些原来的数据
print(dataset.head())
train,test=SplitData(dataset)
#feature_importances(dataset)
#RandomForestClassifie(dataset)
print(train.head())
print(test.head())
test1=pd.DataFrame(test,columns=['FINVEST_STATUS','ZIP1','FTRADE','RESOURE','FRANK','CLIENTLEVELE1','FANNUAL','LENDERID','admit'])
#score_item_list,set1,user_dic=find(train,'108146')
#probability(score_item_list)
#probability(score_item_list)
##################################################################
test_rank,admit=testdatachange(test1)
pd.DataFrame(train,columns=['LENDERID','admit']).to_csv("E://ease-job//work//job//train1.csv")
train1_contents=open("E://ease-job//work//job//train1.csv")
user_dic1=getuser_dic(train1_contents)
print(train.head())
train_dic=get_dic(train)
test_dic=get_dic(test)
for i in test_rank:
if i[7] in user_dic1: #当测试集的用户在训练集中则直接找到最邻近的用户即可
if i[7]!='LENDERID' :
score_item_list,set1,user_dic=find(train, i[7])
probability(score_item_list)
else: ##################相当于新用户 这个新用户可能已经投资( 方法1) 未投资( 新用户的冷启动)
if i[7]!='LENDERID':
user,item=newcustomer(train_dic,i)
i.append([probabiliter(item)])
print i[11:]
print("############################################################################################################################################")
#print(ranks,admit)
##判断客户(新客户//老客户//专门的客户)
#judge(test_rank)
有的时候感觉目标性很重要 我也知道工作不是别人带出来的，但是在这有的时候没有给我明确的目标什么的，准确率，覆盖率，回归率。。。。我自己虽然订了目标我不知道我定的多少是合适的 因为每个项目可能要求的不一样，所以我不知道什么样的结果是成功的模型。
比如职业，学历。。。。
迭代选择特征 选择最合适的特征
虽然我在做这个东西有想法 但是我都没办法讨论这个想法是否正确是否能得到好的结果
这种协同过滤应该项目在特征上的相似性外
还要考虑项目在评价矩阵中的协同相似性。
但是由于 数据没有得到对应的评价矩阵
AHP 层次分析法选择特征，设置特征权重
特征提取之后进行数据降维：层次分析
层次分析法 AHP设置每个特征的权重
1:投资状态
2：行业
多个模型建立：
根据数据量多少；输出目的：分类or回归 选择多个模型进行比较
分别为：
协同过滤：
基于物品协同过滤
新用户冷启动-用户的协同过滤
时间衰减
模型测试:
结果解释：绘图验证曲线判断较高时候是否过度拟合
模型比较：
C:/Users/Administrator/AppData/Local/Temp/document_classification_20newsgroups.py
时间复杂度的比较
C:/Users/Administrator/AppData/Local/Temp/plot_forest_iris.py
模型的比较
系统的冷启动问题：
对于一个新用户 同样采用用户特征向量表示 然后根据特征评价矩阵计算该用户各个特征对资源的综合评价 最后合并预测评价 排序前列的资源推荐给用户
评价矩阵构造
用户对产品的评分
思维：
l 将每个新用户都抽取对应的特征，根据特征评价矩阵 计算各个特征的对资源的综合评价
l 合并预测用户的评价排序前列的产品 推荐
l 根据用户表示矩阵对用户评价矩阵的进行分解得到特征集合对资源集合的关系矩阵得到用户特征对资源的评价矩阵
l
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
