标签需要人工大量时间去标注。

监督学习：标签，分类

非监督学习：没有标签，聚类（相似数据归类）

半监督学习：semi-supervised Learning：有少部分标签。最类似人的生活

强化学习：Reinforcement Learing：基于环境而定

官网：sclkit-learn
样本数量

回归（regression）

  • 回归用于预测，输出连续

    机器学习的“六步走”

    收集数据—>准备数据—>选择/建立模型—>训练模型—>测试模型—>调节模型参数

    机器学习“关键三步”

  • 找一系列函数来实现预期功能：建模问题

  • 找一组合理的评判标准，来评估函数的好坏：评价问题

  • 快速找到性能最佳的函数：优化问题（比如梯度下降）

    过拟合：overfitting

  • 拟合结果

    • 欠拟合
      • 样本不够
    • 拟合完美
      • 拟合完美，恰当拟合测试数据，泛化能力强
    • 过拟合
      • “一丝不苟”拟合数据，泛化能力弱

        过拟合解决方案

  • 降低数据量

  • 正则化
  • Dropout（丢弃、退出）

KNN邻近算法

K值不大于20
输入数据与训练集的数之间距离最小出现频率最高的就是K邻近算法
一些计算矩阵数据相关函数
tile:重复深度为1

a = array([0, 1, 2])
b = tile(a, (2, 1))
print(b)
//结果为[[0, 1, 2], [0, 1, 2]]
找出最小值的索引
>>> x = np.array([3, 1, 2])
>>> np.argsort(x)
array([1, 2, 0])

计算一个简单KNN

  1. # -*- coding:UTF-8 -*-
  2. import numpy as np
  3. import operator
  4. """
  5.     创建数据集
  6.     returns：
  7.         group-数据集组
  8.         lables-分类标签
  9. """
  11. def createDataSet():
  12.     #xy分别代表数据的特征
  13.     #构建4组二维特征 x表示打架，y表示接吻
  14.     group = np.array(([1.8,2.5,3.9],[1.85,2.4,4.2],[3.4,3.3,2.3],[3.7,3.2,1.89],[1.45,3.6,5.6],[7.08,4.3,1.23],[3.3,3.2,2.33],[3.3,3.1,2.33],[3.3,3.4,2.33]))
  15.     #4组数据标签
  16.     lables = ['主队胜利','主队胜利','平局','客队胜利','主队胜利','客队胜利','平局','平局','平局']
  17.     return group,lables
  19. """
  20.     分类器
  21.     a = array([0, 1, 2])
  22.     b = tile(a, (2, 1))
  23.     print(b)
  25.     //结果为
  26.     [[0, 1, 2],  
  27.      [0, 1, 2]]
  29. One dimensional array:一维数组
  31. >>> x = np.array([3, 1, 2])
  32. >>> np.argsort(x)
  33. array([1, 2, 0])
  35.     参数：
  36.         inX：测试数据是数组类型[101.20]
  37.         dataSet-训练集
  38.         labes-分类标签
  39.         k-用于训练的参数选择距离最小的K个点
  40.     返回数据
  41.         sortedClassCount[0][0]-分类结果
  42. """
  43. def classify(inX,dataSet,lables,k):
  44.     #训练集的个数行
  45.     dataSize = dataSet.shape[0]
  46.     #测试数据与训练集计算距离差
  47.     #tile让数组以某种方式重复4次深度1
  48.     diffMat = np.tile(inX,(dataSize,1))-dataSet
  49.     #二维数据平方
  50.     sqDiffMat = diffMat**2
  51.     #sum()所有元素相加，sum(0)列相加，sum(1)行相加而当加入axis=1以后就是将一个矩阵的每一行向量相加
  52.     sqDistances = sqDiffMat.sum(axis=1)
  53.     #最后算出距离D
  54.     D = sqDistances**0.5
  55.     #测试数据与训练集之间的所有距离 并且按照距离最短排序 ，取出索引 索引与lables一一对应
  56.     sortedDistIndices = D.argsort()
  57.     #记录类别次数字典
  58.     classcount = {}
  59.     for i in range(k):
  60.         #取出前K个元素类别
  61.         Vlabel = lables[sortedDistIndices[i]]
  62.         print (Vlabel)
  63.         classcount[Vlabel] = classcount.get(Vlabel,0)+1
  64.     # python3中用items()替换python2中的iteritems()
  65.     # key=operator.itemgetter(1)根据字典的值进行排序
  66.     # key=operator.itemgetter(0)根据字典的键进行排序
  67.     # reverse降序排序字典
  68.     sortClassCount = sorted(classcount.items(),key=operator.itemgetter(1),reverse=True)
  69.     print (classcount)
  70.     print (sortClassCount)
  71.     return sortClassCount[0][0]
  72. if __name__ == '__main__':
  73.     #创建数据集
  74.     group, labels = createDataSet()
  75.     #测试集
  76.     test = [2.60,3.40,2.75]
  77.     #kNN分类
  78.     test_class = classify(test, group, labels, 3)
  79.     #打印分类结果
  80.     print(test_class)

此方法没有对数据进行训练

k-近邻算法的一般流程：

  1. 收集数据：可以使用爬虫进行数据的收集，也可以使用第三方提供的免费或收费的数据。一般来讲，数据放在txt文本文件中，按照一定的格式进行存储，便于解析及处理。
  2. 准备数据：使用Python解析、预处理数据。
  3. 分析数据：可以使用很多方法对数据进行分析，例如使用Matplotlib将数据可视化。
  4. 测试算法：计算错误率。
  5. 使用算法：错误率在可接受范围内，就可以运行k-近邻算法进行分类。

已经了解了k-近邻算法的一般流程，下面开始进入实战内容。

  1. 数据收集：

    数字识别

    训练集trainingDigits.zip
    测试集testDigits.zip

  2. 文件预处理将图片转换成32*32的大小，然后转换为01二进制文本图像

    1. #图片大小转换
    2. def size():
    3.  image=cv2.imread('26.png')
    5.  res=cv2.resize(image,(32,32),interpolation=cv2.INTER_CUBIC)
    6.  cv2.imshow('iker',res)
    8.  cv2.imshow('image',image)
    9.  cv2.imwrite('test.png', res)  # 写入图片
    10.  #cv2.destroyAllWindows()  # 关闭窗口
    11.  cv2.waitKey(0)
    12. #变成32*32的二进制图
    13. def changeTu():
    14.  im = Image.open('test.png')
    15.  width = im.size[0]
    16.  height = im.size[1]
    17.  fh = open('10_1.txt','w')
    18.  for i in range(height):
    19.      for j in range(width):
    20.          color = im.getpixel((j,i))
    21.          print(color)
    22.          colorsum = color[0]+color[1]+color[2]
    23.          print(colorsum)
    24.          if(colorsum == 0):
    25.              fh.write('1')
    26.          else:
    27.              fh.write('0')
    28.      fh.write('\n')
    29.  fh.close()
    30. #改变成向量
    31. def img2vector(filename):
    32.  #创建1x1024零向量
    33.  returnVect = np.zeros((1, 1024))
    34.  #打开文件
    35.  fr = open(filename)
    36.  #按行读取
    37.  for i in range(32):
    38.      #读一行数据
    39.      lineStr = fr.readline()
    40.      #每一行的前32个元素依次添加到returnVect中
    41.      for j in range(32):
    42.          returnVect[0, 32*i+j] = int(lineStr[j])
    43.  #返回转换后的1x1024向量
    44.  return returnVect

    分类器KNN

    ```python def classify0(inX, dataSet, labels, k):

    numpy函数shape[0]返回dataSet的行数

    dataSetSize = dataSet.shape[0]

    在列向量方向上重复inX共1次(横向),行向量方向上重复inX共dataSetSize次(纵向)

    diffMat = np.tile(inX, (dataSetSize, 1)) - dataSet

    二维特征相减后平方

    sqDiffMat = diffMat**2

    sum()所有元素相加,sum(0)列相加,sum(1)行相加

    sqDistances = sqDiffMat.sum(axis=1)

    开方,计算出距离

    distances = sqDistances**0.5

    返回distances中元素从小到大排序后的索引值

    sortedDistIndices = distances.argsort()

    定一个记录类别次数的字典

    classCount = {} for i in range(k):

    1.  #取出前k个元素的类别
    2.  voteIlabel = labels[sortedDistIndices[i]]
    3.  #dict.get(key,default=None),字典的get()方法,返回指定键的值,如果值不在字典中返回默认值。
    4.  #计算类别次数
    5.  classCount[voteIlabel] = classCount.get(voteIlabel,0) + 1

    python3中用items()替换python2中的iteritems()

    key=operator.itemgetter(1)根据字典的值进行排序

    key=operator.itemgetter(0)根据字典的键进行排序

    reverse降序排序字典

    sortedClassCount = sorted(classCount.items(),key=operator.itemgetter(1),reverse=True)

    返回次数最多的类别,即所要分类的类别

    return sortedClassCount[0][0]

```