import random;

import math;

import Iris; # 自定义

import file_handle; # 自定义

#if __name__ == '__main__': #__name__ == '__main__'是Python的main函数入口

def main(print_test=False,print_samples=False):

    follows = []; # 样本集空间（前sampleAmount项）+测试集空间（后 sampleAll-sampleAmount项）

    data = "";    # 样本数据（前sampleAmount项）+测试集空间（后 sampleAll-sampleAmount项）

    sampleAll = 150;

    sampleAmount = 100; # 标记样本集数目（剩余的便作为测试集）

    k = 5;

    test_print = print_test; 

    ########## 一 读取数据集，装载样本集

    ##### 1.1 加载数据集数据

    data = file_handle.read("./dataset/data.txt",1,'r');#1:忽略第一行

    # print(data);

    list = data.split('\n');

    i = 0;

    for line in list: # 如：line = "5.1,3.5,1.4,0.2,Iris-setosa"

        item = line.split(',');# 如：item = [5.1,3.5,1.4,0.2,Iris-setosa]

        label_species = item.pop();#移除最后一项：标记种类

        #print("[test] item:", item,"\tlabel_species:", label_species); # test

        follows.append(Iris.Iris(item,label_species));

        #print("[ ",i," ] ",follows[i].toString());

        i += 1;

        pass;

    random.shuffle(follows); # 【千万注意！！！】由于原数据集是有序的，如果不做乱序处理，预测结果会及其不理想（准确率，趋近于0），当然，这也是这一模型的缺陷之一

    ##### 1.2 选择前100项 作为已标记样本集

    #i = 0;

    #for i in range(sampleAmount):

    #    follows[i].setPredictSpecies(follows[i].label_species);

    #    pass;

    ########## 二 训练测试样本

    ##### 2.1 对101 - 150 项的测试集进行训练/预测

    ## 算法描述：

    ##     遍历测试样本

    ##        计算测试样本与已标记的样本的欧式距离

    ##     对各欧式距离升序排序

    ##     选择前K项的已样本作为一子集( 即 选择最近的K项邻居作为参照标准)

    ##        遍历统计，已标记子集的花朵种类何种花朵数目种类最多

    ##        设置当前测试样本的预测花朵种类为该种

    ##     结束。

    ## 注释：花的种类分别为：Iris-setosa、Iris-versicolor、Iris-virginica；共计3种。

    offset = 0; # 测试空间偏移量：目的是为了将通过偏移量，增大原已标记样本空间的样本数量 即 使已预测的测试样本加入参照样本空间。

    for x in range(sampleAmount,sampleAll):# x：测试样本下标

        weights = [];# 对各欧式距离(权值)的升序排序列表

        for y in range(0,sampleAmount+offset):

            result = (math.sqrt( + \

                               math.pow(follows[y].features[0] - follows[x].features[0],2) + \

                               math.pow(follows[y].features[1] - follows[x].features[1],2) + \

                               math.pow(follows[y].features[2] - follows[x].features[2],2) + \

                               math.pow(follows[y].features[3] - follows[x].features[3],2)), y);# 存储x，方便排序后定位花朵

            #print("[test] weights[x]:", result);

            weights.append(result);

            pass;

        weights.sort(key = lambda item:item[0]); # 以各元组内第一首项[欧氏距离]为键，默认升序排序

        if test_print:

            for m in range(len(weights)): # 输出预测权重

                print("[test] weights[",m,"]:",weights[m],"\tweights[",m,"][1] > ",weights[m][1],":",follows[weights[m][1]].toString());

        kinds_count = {"Iris-setosa":0,"Iris-versicolor":0,"Iris-virginica":0}; # 对已标记样本空间中各种花的数目统计作初始化

        for z in range(0,k): # 选择前K项的已样本作为一子集( 即 选择最近的K项邻居作为参照标准)

            if test_print:

                print("[test] 排名前",z+1,"项 follows[",z,"]:",follows[weights[z][1]].toString());

            label_species = follows[weights[z][1]].label_species;

            if(label_species == 'Iris-setosa'):

                kinds_count["Iris-setosa"] += 1;

            elif label_species == 'Iris-versicolor':

                kinds_count["Iris-versicolor"] += 1;

            elif label_species == 'Iris-virginica':

                kinds_count['Iris-virginica'] += 1;

            else:

                print("[ERROR:Unknown Species] follows[",weight[z][1],"]:",follows[weight[z][1]]);

            pass;

        result =  max(kinds_count.items(), key = lambda item:item[1]); # 取统计花类数字典中最大值对应的序列

        follows[x].predict_species = result[0]; # 标记预测种类

        if test_print:

            print("[test] 预测结果",result, " [follows[",x,"].predict_species]:", follows[x].predict_species); # test

        offset += 1;

        #for test in range(len(weights)): # 测试-输出距离权值结果

        #    print("[",test,"] weights:",weights[test][0],"\t",follows[weights[test][1]].toString());

        #    pass;

        pass;

    ########## 三 计算预测准确率

    rate = 0.0;

    i = 0;

    for i in range(sampleAmount,len(follows)):

        if(follows[i].label_species == follows[i].predict_species):

            rate += 1;

        else:

            print("[预测错误样本] follow[",i,"]:",follows[i].toString());

        pass;

    pass;

    rate = rate / (sampleAll - sampleAmount);

    print("预测准确率：",rate);

    if print_samples:

        for i in range(0,len(follows)):

            print(follows[i].toString());

            pass;

    pass;

main(False,True);

'Iris module [class] '

__author__ = 'Johnny Zen'

class Iris:

    """

    Iris花(类)

    [Demo]

    iris = Iris([5.1,3.5,1.4,0.2],"Iris-setosa");

    print(iris.toString());

    iris.setPredictSpecies('Iris-setosa');

    print(iris.toString());

    print(iris.label_species);

    =======================

    [features][5.1, 3.5, 1.4, 0.2]    [label-species]Iris-setosa    [predict-species]None

    [features][5.1, 3.5, 1.4, 0.2]    [label-species]Iris-setosa    [predict-species]Iris-setosa

    Iris-setosa

    """

    features = [];

    label_species = None; # 标记种类

    predict_species = None; # 预测种类

    def __init__(self,features,label_species=None):

        if type(features).__name__ == 'list':

            self.features = features;

        else:

            self.features = list(features); # 此list方法对list对象执行将产生错误

            pass;

        for x in range(len(self.features)): # 列表内元素字符串转实数

            self.features[x] = float(self.features[x]);

        self.label_species = label_species;

        pass;

    def setPredictSpecies(self,predict_species=None):#设置预测种类

        self.predict_species = predict_species;

        pass;

    def toString(self):#与一般函数定义不同，类方法必须包含参数 self[第一个参数]

        return "[features]" + str(self.features) + "\t[label]" + str(self.label_species + "\t[predict]" + str(self.predict_species));

        pass;

    pass;

"file_handle module [function]:read(filepath,ignore=0,mode='r')"

def read(filepath,ignore=0,mode='r'):

    try:

        file = open(filepath,mode);

        ## file_content = file.read();

        file_content = '';

        i = 0;

        for i in range(0,ignore):

            file.readline();

            ##print(i);

            ##print(file.readline());

        for line in file.readlines():

            file_content += line;

    finally:

        if file:

            file.close();

        #print(file_content);

        return file_content;

    pass;