1. import numpy as np
  2. from sklearn import preprocessing
  3. from sklearn.naive_bayes import GaussianNB 
  5. ###STEP1###
  6. # 加载数据
  7. input_file = r'R:\Ricky\程序\数据仓库与挖掘\实验五_分类算法\adult.data.txt'
  8. X = []
  9. y = []
  10. num_lessthan50k = 0
  11. num_morethan50k = 0
  12. num_threshold = 30000  # 数据总数
  13. with open(input_file, 'r') as f:
  14.     for line in f.readlines():
  15.         if '?' in line:   # 如果数据存在缺失，则剔除该行数据
  16.             continue
  17.             data = line[:-1].split(', ')
  18.             if data[-1] == '<=50K' and num_lessthan50k < num_threshold:
  19.                 X.append(data)
  20.                 num_lessthan50k = num_lessthan50k + 1
  21.                 # 问题一：依据target的不同，各选取相同大小的数据，即选取'<=50K'与'>50K'数量相等的数据
  22.                 if data[-1] == '>50K' and num_morethan50k < num_threshold:
  23.                     X.append(data)
  24.                     num_morethan50k = num_morethan50k + 1
  26.                     if num_lessthan50k >= num_threshold and num_morethan50k >= num_threshold:
  27.                         break
  28.                         X = np.array(X)
  29.                         for i,item in enumerate(X[0]):
  30.                             print(i,item)
  32.                             ###STEP2###
  33.                             label_encoder = [] 
  34.                             X_encoded = np.empty(X.shape)
  35.                             # 这里只取X[0]是因为数据的类型都一样，只需要判断该位置是否为字符串即可，所以只需要一个样例。
  36.                             for i,item in enumerate(X[0]):  # eunm枚举类，形同 将可迭代数据['hello','world']转化为：[(0,'hello'),(1,'world')]
  37.                                 if item.isdigit():   # 判断是否为数值型
  38.                                     X_encoded[:, i] = X[:, i] # 一维全匹配
  39.                                 else:
  40.                                     le=preprocessing.LabelEncoder()
  41.                                     label_encoder.append(le)
  42.                                     # 问题二：转换数据的属性，已知原数据中含有英文字符，请将英文转换为数值型，提示：使用preprocessing.LabelEncoder()方法
  43.                                     X_encoded[:,i] = le.fit_transform(X[:,i])
  45.                                     X = X_encoded[:, :-1].astype(int)
  46.                                     y = X_encoded[:, -1].astype(int)
  49.                                     ###STEP3###
  50.                                     # 问题三：创建分类器并进行训练
  51.                                     # 交叉验证
  52.                                     # from sklearn import cross_validation 该方法在新版sklearn中已被移动，不能这样导入
  53.                                     from sklearn.model_selection import train_test_split,cross_val_score
  54.                                     X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, random_state=5)
  55.                                     classifier_gaussiannb = GaussianNB()
  56.                                     classifier_gaussiannb.fit(X_train, y_train)
  57.                                     y_test_pred = classifier_gaussiannb.predict(X_test)
  58.                                     # # 问题三：计算F1得分
  59.                                     f1 = cross_val_score(classifier_gaussiannb,X,y,scoring='f1_weighted',cv=5)
  61.                                     print ("F1 score: " + str(round(100*f1.mean(), 2)) + "%")
  64.                                     ###STEP4###
  65.                                     # 创建个例，将其进行同样编码处理
  66.                                     input_data = ['39', 'State-gov', '77516', 'Bachelors', '13', 'Never-married', 'Adm-clerical', 'Not-in-family', 'White', 'Male', '2174', '0', '40', 'United-States'] 
  67.                                     count = 0
  68.                                     input_data_encoded = [-1] * len(input_data)
  69.                                     for i,item in enumerate(input_data):
  70.                                         if item.isdigit():
  71.                                             input_data_encoded[i] = int(input_data[i])
  72.                                         else:
  73.                                             input_data_encoded[i] = int(label_encoder[count].transform([input_data[i]]))
  74.                                             count = count + 1 
  75.                                             input_data_encoded = np.array(input_data_encoded)
  76.                                             # 问题四：请将个体进行预测分类，并输出结果
  77.                                             # 预测可以直接调用 predict方法
  78.                                             output_class = classifier_gaussiannb.predict(input_data_encoded.reshape(1,-1)) # 这里需要降维，否则会报错
  80. print (label_encoder[-1].inverse_transform(output_class)[0])
  1. import numpy as np
  2. from sklearn import preprocessing
  3. from sklearn.naive_bayes import GaussianNB 
  5. ###STEP1###
  6. # 加载数据
  7. input_file = r'R:\Ricky\程序\数据仓库与挖掘\实验五_分类算法\adult.data.txt'
  8. X = []
  9. y = []
  10. num_lessthan50k = 0
  11. num_morethan50k = 0
  12. num_threshold = 30000  # 数据总数
  13. with open(input_file, 'r') as f:
  14.     for line in f.readlines():
  15.         if '?' in line:   # 如果数据存在缺失，则剔除该行数据
  16.             continue
  17.         data = line[:-1].split(', ')
  18.         if data[-1] == '<=50K' and num_lessthan50k < num_threshold:
  19.             X.append(data)
  20.             num_lessthan50k = num_lessthan50k + 1
  21.         # 问题一：依据target的不同，各选取相同大小的数据，即选取'<=50K'与'>50K'数量相等的数据
  22.         if data[-1] == '>50K' and num_morethan50k < num_threshold:
  23.             X.append(data)
  24.             num_morethan50k = num_morethan50k + 1
  26.         if num_lessthan50k >= num_threshold and num_morethan50k >= num_threshold:
  27.             break
  28. X = np.array(X)
  30. ###STEP2###
  31. label_encoder = [] 
  32. X_encoded = np.empty(X.shape)
  33. # 这里只取X[0]是因为数据的类型都一样，只需要判断该位置是否为字符串即可，所以只需要一个样例。
  34. for i,item in enumerate(X[0]):  # eunm枚举类，形同 将可迭代数据['hello','world']转化为：[(0,'hello'),(1,'world')]
  35.     if item.isdigit():   # 判断是否为数值型
  36.         X_encoded[:, i] = X[:, i] # 一维全匹配
  37.     else:
  38.         le=preprocessing.LabelEncoder()
  39.         label_encoder.append(le)
  40.         # 问题二：转换数据的属性，已知原数据中含有英文字符，请将英文转换为数值型，提示：使用preprocessing.LabelEncoder()方法
  41.         X_encoded[:,i] = le.fit_transform(X[:,i])
  43. X = X_encoded[:, :-1].astype(int)
  44. y = X_encoded[:, -1].astype(int)
  46. # 创建KNN分类器
  47. from sklearn.neighbors import KNeighborsClassifier
  48. from sklearn.preprocessing import StandardScaler
  49. # 创建knn前需要先标准化数据
  50. stand = StandardScaler()
  52. # 创建 5 个邻居的分类器
  53. knn = KNeighborsClassifier(n_neighbors=5, n_jobs=1)
  55. # 交叉验证
  56. from sklearn.model_selection import train_test_split,cross_val_score
  57. X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, random_state=5)
  58. knn.fit(X_train,y_train)
  59. y_test_pred = knn.predict(X_test)
  61. # 计算得分
  62. f1 = cross_val_score(knn,X,y,scoring='f1_weighted',cv=5)
  63. print ("F1 score: " + str(round(100*f1.mean(), 2)) + "%")

自己实现KNN算法

  1. import numpy as np
  2. import operator
  3. import pandas as pd
  4. # newInput: 新输入的待分类数据(x_test)，本分类器一次只能对一个新输入分类
  5. # dataset：输入的训练数据集(x_train),array类型，每一行为一个输入训练集
  6. # labels：输入训练集对应的类别标签(y_train)，格式为['A','B']而不是[['A'],['B']]
  7. # k：近邻数
  8. # weight：决策规则，"uniform" 多数表决法，"distance" 距离加权表决法
  10. def KNNClassify(newInput, dataset, labels, k, weight):
  11.     numSamples = dataset.shape[0]
  13.     """step1: 计算待分类数据与训练集各数据点的距离（欧氏距离：距离差值平方和开根号）"""
  14.     diff = np.tile(newInput, (numSamples, 1)) - dataset  # 凸显numpy数组的高效性——元素级的运算
  15.     squaredist = diff ** 2
  16.     distance = (squaredist.sum(axis=1)) ** 0.5  # axis=1,按行累加
  18.     """step2：将距离按升序排序，并取距离最近的k个近邻点"""
  19.     # 对数组distance按升序排序，返回数组排序后的值对应的索引值
  20.     sortedDistance = distance.argsort()
  22.     # 定义一个空字典，存放k个近邻点的分类计数
  23.     classCount = {}
  25.     # 对k个近邻点分类计数，多数表决法
  26.     for i in range(k):
  27.         # 第i个近邻点在distance数组中的索引,对应的分类
  28.         votelabel = labels[sortedDistance[i]]
  29.         if weight == "uniform":
  30.             # votelabel作为字典的key，对相同的key值累加（多数表决法）
  31.             classCount[votelabel] = classCount.get(votelabel, 0) + 1
  32.         elif weight == "distance":
  33.             # 对相同的key值按距离加权累加（加权表决法）
  34.             classCount[votelabel] = classCount.get(votelabel, 0) + (1 / distance[sortedDistance[i]])
  35.         else:
  36.             print("分类决策规则错误！")
  37.             print("\"uniform\"多数表决法\"distance\"距离加权表决法")
  38.             break
  40.             # 对k个近邻点的分类计数按降序排序，返回得票数最多的分类结果
  41.     sortedClassCount = sorted(classCount.items(), key=operator.itemgetter(1), reverse=True)
  42.     if weight == "uniform":
  43.         print("新输入到训练集的最近%d个点的计数为：" % k, "\n", classCount)
  44.         print("新输入的类别是:", sortedClassCount[0][0])
  46.     elif weight == "distance":
  47.         print("新输入到训练集的最近%d个点的距离加权计数为：" % k, "\n", classCount)
  48.         print("新输入的类别是:", sortedClassCount[0][0])
  50.     return sortedClassCount[0][0]
  52. iris=pd.read_csv("iris.txt") #读取数据文件
  53. iris.head()
  55. iris_x=iris.iloc[:,[0,1,2,3]] #基于索引位来选取数据集
  56. iris_y=iris.iloc[:,[4]]
  59. indices=np.random.permutation(len(iris_x)) #将鸢尾花的长度数据打乱
  61. iris_x_train=iris_x.iloc[indices[0:130]]
  62. iris_y_train=iris_y.iloc[indices[0:130]]
  64. iris_x_test=iris_x.iloc[indices[130:150]]
  65. iris_y_test=iris_y.iloc[indices[130:150]]
  67. # 将dataframe格式的数据转换为numpy array格式，便于 调用函数计算
  68. iris_x_train=np.array(iris_x_train)
  69. iris_y_train=np.array(iris_y_train)
  71. iris_x_test=np.array(iris_x_test)
  72. iris_y_test=np.array(iris_y_test)
  74. # 将labels的形状设置为(130,)
  75. iris_y_train.shape=(130,)
  77. # if __name__ == '__main__':
  78. #     test_index = 12
  79. #     predict = KNNClassify(iris_x_test[test_index], iris_x_train, iris_y_train, 20, "distance")
  80. #     print(predict)
  81. #     print("新输入的实际类别是：", iris_y_test[test_index])
  82. #     print("\n")
  83. #
  84. #     if predict == iris_y_test[test_index]:
  85. #         print("预测准确!")
  86. #     else:
  87. #         print("预测错误！")