对客户推荐产品模型+python代码

#-*- 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<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)