问题1:扔下圆球的位置(feature特征变量)变化,最终掉落奖项(label结果标签)的变化

  • feature ----输入
  • f(x) ----模型,算法
  • label ----输出

  大量已知的数据,训练得出f(x)

  • 一般的三步

    • 收集数据feature,label
    • 选择数据模型建立feature,label的关系--f(x)
    • 根据选择的模型进行预测 
  • 人类建立模型:多次尝试增加经验提高预测到达公司的时间
  • 机器学习:利用统计学,概率论,信息论的数学方法,利用已知的数据,创建一种模型,利用这种模型进行预测(高考与之类似)
    • 机器学习经典模型:KNN模型(人以类聚,物以群分)

      • 基本步骤  

        • 1.采集数据
        • 2.计算实验数据与预测位置的距离
        • 3.按照距离从小到大排序
        • 4.选取最顶部的K条记录,得到最大概率的落点
        • 5.预测预测位置的落点
      • python实现
        • import numpy as np
          import collections as c
          # 1.采集数据
          data = np.array([
          [154, 1],
          [126, 2],
          [70, 2],
          [196, 2],
          [161, 2],
          [371, 4],
          ]) # feature,label
          feature = data[:, 0]
          label = data[:, -1] # 2.计算实验数据与预测点的距离
          predictPoint = 200
          distance = list(map(lambda x: abs(x - predictPoint), feature)) # 3.按照距离从小到大排序,排序下标
          sortindex = np.argsort(distance) # 4.选取最顶部的K条记录,得到最大概率的落点,假设K=3
          sortedlabel = label[sortindex]
          k = 3
          # 预测结果[(结果,次数)]
          # 5.预测预测位置的落点
          predictlabel = c.Counter(sortedlabel[0:k]).most_common(1)[0][0] print(predictlabel)
      • 代码封装
        • import numpy as np
          import collections as c # 代码封装 def knn(k, predictPoint, feature, label):
          distance = list(map(lambda x: abs(x - predictPoint), feature))
          sortindex = np.argsort(distance)
          sortedlabel = label[sortindex]
          predictlabel = c.Counter(sortedlabel[0:k]).most_common(1)[0][0]
          return predictlabel if __name__ == '__main__':
          data = np.array([
          [154, 1],
          [126, 2],
          [70, 2],
          [196, 2],
          [161, 2],
          [371, 4],
          ])
          # feature,label
          feature = data[:, 0]
          label = data[:, -1]
          k = 3
          predictPoint = 200
          res = knn(k, predictPoint, feature, label)
          print(res)
      • 实际数据验证
        • 数据集https://pan.baidu.com/s/1rw5aFlVzZb6SBdY09Rckhg
        • import numpy as np
          import collections as c # 代码封装 def knn(k, predictPoint, feature, label):
          distance = list(map(lambda x: abs(x - predictPoint), feature))
          sortindex = np.argsort(distance)
          sortedlabel = label[sortindex]
          predictlabel = c.Counter(sortedlabel[0:k]).most_common(1)[0][0]
          return predictlabel if __name__ == '__main__':
          data = np.loadtxt("数据集/data0.csv", delimiter=",")
          # feature,label
          feature = data[:, 0]
          label = data[:, -1]
          k = 3
          predictPoint = 300
          res = knn(k, predictPoint, feature, label)
          print(res)

        训练集和测试集

        • 打散数据得到训练集和测试集
        • import numpy as np
        • import collections as c
          
          # 代码封装
          
          def knn(k, predictPoint, feature, label):
          distance = list(map(lambda x: abs(x - predictPoint), feature))
          sortindex = np.argsort(distance)
          sortedlabel = label[sortindex]
          predictlabel = c.Counter(sortedlabel[0:k]).most_common(1)[0][0]
          return predictlabel if __name__ == '__main__':
          data = np.loadtxt("数据集/data0.csv", delimiter=",")
          # 打散数据
          np.random.shuffle(data)
          # 训练90%
          traindata = data[100:-1]
          # 测试10%
          testdata = data[0:100]
          # 保存训练数据,测试数据
          np.savetxt("data0-test.csv", testdata, delimiter=",", fmt="%d")
          np.savetxt("data0-train.csv", traindata, delimiter=",", fmt="%d") traindata = np.loadtxt("data0-train.csv", delimiter=",") # feature,label
          feature = traindata[:, 0]
          label = traindata[:, -1]
          max_accuracy = 0
          max_k = []
          # 预测点,来自测试数据的每一条记录
          testdata = np.loadtxt("data0-test.csv", delimiter=",")
          for k in range(1,100):
          count = 0
          for item in testdata:
          predict = knn(k, item[0], feature, label)
          real = item[1]
          if predict == real:
          count += 1 accuracy = count * 100.0 / len(testdata)
          if accuracy >= max_accuracy:
          max_accuracy = accuracy
          max_k.append(k)
          print("k = {},准确率:{}%".format(k,count*100.0/len(testdata)))
          print(set(max_k)) 
      • 多维数据的距离的选取

        • 欧式距离即可

      • 预测不是很准确
        • 1.模型的参数选择不够好,调参---调参工程师

          • K选择太小,噪音干扰太明显
          • K选择太大,其他类型的会涵盖 
          • K值的评价标准
            • 训练集trainData---得到模型
            • 测试集testData---验证模型 
          • 经验:K一般选取样本集开平方    
        • 2.影响因子不够多
          • 增加数据的维度

            • 球的颜色导致弹性不同
            • 特殊数据的导入
              • import numpy as np
                
                def colornum(str):
                dict = {"红":0.50,"黄":0.51,"蓝":0.52,"绿":0.53,"紫":0.54,"粉":0.55}
                return dict[str] data = np.loadtxt('数据集/data1.csv',delimiter=",",converters={1:colornum},encoding="gbk")
                print(data)
        • 3.样本数据量不够
        • 4.选择的模型不够好,选择其他机器学习的模型   
    • 线性回归  
      • 是一种总结规律,总结模型的解决方法。不需要全数据集
      • 损失函数:评测算法的好坏
      • 最小均方差 
      • 最小均方差越接近0越好
      • 步骤
        • 1.随机选取m和b
        • 2.分别计算m和b的偏导数
        • 3.如果m和b的偏导都很小,就成功
        • 4.根据学习速率,计算出修改的值
        • 5.b和m分别减去要修改的值  
      • python实import numpy as np
      • # data = np.array([
        # [80, 200],
        # [95, 230],
        # [104, 245],
        # [112, 274],
        # [125, 259],
        # [135, 262],
        # ]) data = np.loadtxt('数据集/cars.csv', delimiter=",", skiprows=1, usecols=(4, 1)) m = 1
        b = 1 xarray = data[:, 0]
        yreal = data[:, -1]
        learningrate = 0.00001 # 梯度下降
        def grandentdecent():
        # 求斜率
        bslop = 0
        for index, x in enumerate(xarray):
        bslop = bslop + m * x + b - yreal[index]
        bslop = bslop * 2 / len(xarray)
        # print("对b求导的斜率={}".format(bslop)) mslop = 0
        for index, x in enumerate(xarray):
        mslop = mslop + (m * x + b - yreal[index]) * x
        mslop = mslop * 2 / len(xarray)
        # print("对m求导的斜率={}".format(mslop)) return (bslop, mslop) def train():
        for i in range(1, 10000000):
        bslop, mslop = grandentdecent()
        global m
        m = m - mslop * learningrate
        global b
        b = b - bslop * learningrate
        if (abs(mslop) < 0.5 and abs(bslop) < 0.5):
        break print("m={},b={}".format(m, b)) if __name__ == '__main__':
        train() # 用训练集得到公式
        # 用测试集验证正确率
      • import numpy as np
        
        # 面积,房价
        data = np.array([
        [80, 200],
        [95, 230],
        [104, 245],
        [112, 274],
        [125, 259],
        [135, 262],
        ])
        # 1.feature,label,axis=1保留原始维度
        feature = np.expand_dims(data[:, 0], axis=1)
        # feature = data[:,0:1]
        label = np.expand_dims(data[:, -1], axis=1) # 2.weight
        m = 1
        b = 1 weight = np.array([
        [m],
        [b],
        ])
        # 3.feature*weight,需要在feature后面补一列1---每一行代表mx+b
        feature = np.append(feature, np.ones(shape=(6, 1)), axis=1) print(feature)
        # 4.feature*weight - label 得到差值difference
        difference = np.dot(feature, weight) - label
        # 5.feature^T*difference/n 先将feature转置在乘,得到对B和M的偏导bslop,mslop
        bmslop = np.dot(feature.T, difference)
        bmslop = bmslop*2/len(feature)
        # 6.仅需使其数字接近0即可         
    • 图形变化

      • import matplotlib.pyplot as plt
        import numpy as np
        import math points = np.array([
        [0, 0],
        [0, 5],
        [3, 5],
        [3, 4],
        [1, 4],
        [1, 3],
        [2, 3],
        [2, 2],
        [1, 2],
        [1, 0],
        [0, 0],
        ])
        plt.plot(points[:, 0], points[:, 1])
        for i in range(1,13):
        # # 1.平移
        # matrix = np.array([0.5*i, 0])
        # newpoints = points + matrix
        # 2.旋转
        # matrix = np.array([
        # [math.cos(math.pi/6),-math.sin(math.pi/6)],
        # [math.sin(math.pi/6),math.cos(math.pi/6)],
        # ])
        # points = np.dot(points,matrix)
        # 3.缩放
        matrix = np.array([
        [1.05,0],
        [0,1.05],
        ])
        points = np.dot(points, matrix)
        plt.plot(points[:, 0], points[:, 1])
        plt.xlim(-10,10)
        plt.ylim(-10,10)
        plt.show()  
    • 逻辑回归

      • 将线性回归置于e的指数即可

      • e的求法

        • import math
          
          n = 1000000
          
          e = math.pow((1+1.0/n),n)
          
          print(e)
      • 激活函数,sigmoid 

        • 逻辑回归实现梯度下降

          • import numpy as np
            
            data = np.array([
            [5, 0],
            [15, 0],
            [25, 1],
            [35, 1],
            [45, 1],
            [55, 1],
            ]) # 1.feature,label,axis=1保留原始维度
            feature = np.expand_dims(data[:, 0], axis=1)
            # feature = data[:,0:1]
            label = np.expand_dims(data[:, -1], axis=1) learingrate = 0.00001
            m = 1
            b = 1 weight = np.array([
            [m],
            [b],
            ]) feature = np.append(feature, np.ones(shape=(6, 1)), axis=1) def gradentDecent():
            predict = 1 / (1 + np.exp(-np.dot(feature, weight)))
            difference = predict - label
            bmslop = np.dot(feature.T, difference)
            bmslop = bmslop / len(feature)
            return bmslop def train():
            for i in range(1, 10):
            slop = gradentDecent()
            global weight
            weight = weight - learingrate * slop
            print(slop) if __name__ == '__main__':
            train()
    • 神经网络:主要用于分类和聚类

      • 用一条线划分两种类型的属性---分割线计算

      • 高维空间,只是变成了矩阵相乘---用面分割

      • 神经元=激活函数=f(x)

      • 手工拟合OR,AND,XOR

      • 感知机:梯度下降实现

        • 随便划线,感知点的情绪(- -),向着开心的方向进行移动

        • 调整线的斜率,使结果更好  

        • 梯度下降:连续可导,可以求斜率

        • MSE最小均方差

        • Cross-entropy交叉熵

          • p(red)=p(blue)

          • sigmoid函数处理线性函数,    

  • 聚类算法

    • 相似的事务归为一类-标签化---物以类聚

    • k-means
      • k:中心点的个数,质心

      • means:求平均

      • 不断迭代,更新质心 

      • 步骤

        • 1.选择聚类的个数K

        • 2.生成K个聚类中心点

        • 3.计算所有样本点到聚类中心点的距离

        • 4.更新质心(求聚类后的x,y平均值),迭代聚类

        • 5.重复4直到满足收敛要求

        • import numpy as np
          import matplotlib.pyplot as plt
          from sklearn.cluster import MiniBatchKMeans, KMeans
          # 测量
          from sklearn import metrics
          # 球状簇
          from sklearn.datasets.samples_generator import make_blobs # 生成数据集,样本数=1000,特征数=2,中心=以哪些点为中心生成样本点,标准差=围绕中心的标准差,随机状态值=每次运行生成散点图一致
          x, y = make_blobs(n_samples=1000, n_features=2, centers=([-1, -1], [0, 0], [1, 1], [2, 2]),
          cluster_std=(0.4, 0.2, 0.2, 0.2), random_state=9)
          # 生成散点图
          plt.scatter(x[:, 0], x[:, 1], marker="o")
          plt.show() # 可视化
          for index, k in enumerate((2, 3, 4, 5)):
          plt.subplot(2, 2, index + 1)
          # 随机选取200个点,分别用特征2,3,4,5作为特征值,进行K——means
          y_pred = MiniBatchKMeans(n_clusters=k, batch_size=200, random_state=9).fit_predict(x)
          # 聚类效果评分
          score = metrics.calinski_harabaz_score(x, y_pred)
          plt.scatter(x[:, 0], x[:, 1], c=y_pred)
          plt.text(.99,.01,
          ('k=%d,score:%.2f' % (k, score)),
          fontsize=10,
          transform=plt.gca().transAxes,
          horizontalalignment="right")
          plt.show()
      •    

      • 完整的预处理例子

        • '''
          完整的机器学习流程
          ''' # 1.导入库
          import numpy as np
          import pandas as pd
          import matplotlib.pyplot as plt
          import seaborn as sns
          import numpy.random as nr
          import math
          from sklearn.cluster import MiniBatchKMeans, KMeans
          # 测量
          from sklearn import metrics
          # 球状簇
          from sklearn.datasets.samples_generator import make_blobs # 2.观察数据集
          # 路径带中文,前面先用open打开
          auto_prices = pd.read_csv(open('工业汽车数据集应用实践/Automobile price data _Raw_.csv'))
          # print(auto_prices.head(20)) # 3.数据的预处理,重新编码
          auto_prices.columns = (str.replace('-', '_') for str in auto_prices.columns) # 4.处理缺失值
          # 找出所有缺失值
          (auto_prices.astype(np.object) == '?').any() for col in auto_prices.columns:
          if auto_prices[col].dtypes == object:
          count = 0
          count = [count + 1 for x in auto_prices[col] if x == '?']
          print(col + ' ' + str(sum(count))) # 处理缺失值
          auto_prices.drop('normalized_losses', axis=1, inplace=True)
          cols = ['price', 'bore', 'stroke', 'horsepower', 'peak_rpm']
          for column in cols:
          auto_prices.loc[auto_prices[column] == '?', column] = np.nan
          auto_prices.dropna(axis=0, inplace=True)
          print(auto_prices.shape) # 5.转换列数据类型
          for column in cols:
          auto_prices[column] = pd.to_numeric(auto_prices[column])
          print(auto_prices[cols].dtypes) # 6.特征工程
          # 汇总变量类别,转换ln,交互的变量合并
          # 聚合特征变量
          print(auto_prices['num_of_cylinders'].value_counts())
          # print(auto_prices.columns) cylinder_categories = {
          'three': 'three_four',
          'four': 'three_four',
          'five': 'five_six',
          'six': 'five_six',
          'eight': 'eight_twelve',
          'twelve': 'eight_twelve', }
          auto_prices['num_of_cylinders'] = [cylinder_categories[x] for x in auto_prices['num_of_cylinders']]
          print(auto_prices['num_of_cylinders'].value_counts()) # 7.箱型图
          # 哪个特征影响价格走向
          def plot_box(auto_price, col, col_y='price'):
          sns.set_style('whitegrid')
          sns.boxplot(col, col_y, data=auto_price)
          plt.xlabel(col)
          plt.ylabel(col_y)
          plt.show() plot_box(auto_prices, 'num_of_cylinders') print(auto_prices['body_style'].value_counts())
          body_cats = {
          'sedan': 'sedan',
          'hatchback': 'hatchback',
          'wagon': 'wagon',
          'hardtop': 'hardtop_convert',
          'convertible': 'hardtop_convert', }
          auto_prices['body_style'] = [body_cats[x] for x in auto_prices['body_style']]
          print(auto_prices['body_style'].value_counts()) # 8.特征图
          # 哪个特征有别于其他特征
          def plot_box(auto_price, col, col_y='price'):
          sns.set_style('whitegrid')
          sns.boxplot(col, col_y, data=auto_price)
          plt.xlabel(col)
          plt.ylabel(col_y)
          plt.show() plot_box(auto_prices, 'body_style') # 9.转换变量
          def hist_plot(vals, lab):
          sns.distplot(vals)
          plt.title('Histogram of' + lab)
          plt.xlabel('value')
          plt.ylabel('Density')
          plt.show() hist_plot(auto_prices['price'], 'prices')
          # 对数转换
          auto_prices['log_price'] = np.log(auto_prices['price'])
          hist_plot(auto_prices['log_price'], 'log_price') # 10.可视化
          # 看价格与其他特征是否存在线性或非线性的关系
          def plot_scatter_shape(auto_prices, cols, shape_col='fuel_type', col_y='log_price', alpha=0.2):
          shapes = ['+', 'o', 's', 'x', '^']
          unique_cats = auto_prices[shape_col].unique()
          for col in cols:
          sns.set_style('whitegrid')
          for i, cat in enumerate(unique_cats):
          temp = auto_prices[auto_prices[shape_col] == cat]
          sns.regplot(col, col_y, data=temp, marker=shapes[i], label=cat,
          scatter_kws={'alpha': alpha}, fit_reg=False, color='blue') plt.title('scatter plot of' + col_y + 'vs.' + col)
          plt.xlabel(col)
          plt.ylabel(col_y)
          plt.legend()
          plt.show() num_cols = ['curb_weight', 'engine_size', 'horsepower', 'city_mpg']
          plot_scatter_shape(auto_prices, num_cols)
    • 算法效果的衡量标准

      • SSE(Sum of Squear due to Error)误差平方和

        • 每个点跟质心的距离  
      • K值确定:Elbow method 肘方法

        • SSE跟聚类个数画图
        • 找出拐点来确定聚类数  
        •         
      • 轮廓系数法(Silhouette Coefficient)
        • 根据轮廓边缘的变化感知聚类的凝聚度和分离度
        •   
      • CH(Calinski-Harabasz)

        • 数据类别距离平方和越小越好,类别之间平方和越大越好

        •                   

                

  

<人工智能>人工智能基础的更多相关文章

  1. 饮冰三年-人工智能-Python-17Python基础之模块与包

    一.模块(modue) 简单理解一个.py文件就称之为一个模块. 1.1 模块种类: python标准库 第三方模板 应用程序自定义模块(尽量不要与内置函数重名) 1.2 模块导入方法 # impor ...

  2. [人工智能]NumPy基础

    理解NumPy 本文主要介绍NumPy的基础知识,NumPy是一个功能强大的Python库,允许更高级的数据操作和数学计算. 什么是NumPy NumPy,来源自两个单词:Numerical和Pyth ...

  3. [人工智能]Pytorch基础

    PyTorch基础 摘抄自<深度学习之Pytorch>. Tensor(张量) PyTorch里面处理的最基本的操作对象就是Tensor,表示的是一个多维矩阵,比如零维矩阵就是一个点,一维 ...

  4. 饮冰三年-人工智能-Python-16Python基础之迭代器、生成器、装饰器

    一:迭代器: 最大的特点:节省内存 1.1 迭代器协议 a:对象必须提供一个next方法, b:执行方法要么返回迭代中的下一项,要么抛弃一个Stopiteration异常, c:只能向后不能向前. 1 ...

  5. 饮冰三年-人工智能-Python-15Python基础之文件处理

    # 写文件--开始 f=open('test','w',encoding="utf-8") #如果有则写,没有就创建 print(f.writable()) #True f.wri ...

  6. 饮冰三年-人工智能-Python-14Python基础之变量与函数

    1:函数:函数是逻辑结构化和过程化的一种编程方法.函数即变量 #参数组:**字典 *列表 def test(x,*args): print(args); print(args[0]); print(& ...

  7. 饮冰三年-人工智能-Python-13Python基础之运算符与数据类型

    1:算数运算符 + - * / ** % // 2: 成员运算符 in not in name = """张三""" if "张& ...

  8. 身边的人工智能&人工智能发展史

    智能家具 扫地机器人 智能音箱 个人助手 在线翻译 谷歌翻译 微软翻译 YouTube 视频翻译 图像识别 人脸识别 AI+摄像头 下棋高手 Alphago 2017年打败柯洁 成为世界第一 Alph ...

  9. 零基础自学人工智能,看这些资料就够了(300G资料免费送)

    为什么有今天这篇? 首先,标题不要太相信,哈哈哈. 本公众号之前已经就人工智能学习的路径.学习方法.经典学习视频等做过完整说明.但是鉴于每个人的基础不同,可能需要额外的学习资料进行辅助.特此,向大家免 ...

随机推荐

  1. 洛谷 P2024 [NOI2001]食物链——带权值的并查集维护

    先上一波题目 https://www.luogu.org/problem/P2024 通过这道题复习了一波并查集,学习了一波带权值操作 首先我们观察到 所有的环都是以A->B->C-> ...

  2. js中继承的实现,原型链的知识点归纳,借用构造函数,组合继承(伪经典继承)

    博客搬迁,给你带来的不便,敬请谅解! http://www.suanliutudousi.com/2017/10/31/js%e4%b8%ad%e7%bb%a7%e6%89%bf%e7%9a%84%e ...

  3. JPA接口整理归纳方法规则

    Keyword Sample JPQL snippet And findByLastnameAndFirstname … where x.lastname = ?1 and x.firstname = ...

  4. Neo4J(Cypher语句)初识

    欢迎各路大神临幸寒舍 以下节点标签为people,friend,用户自己也可以设置成其他标签,查询时需要用到标签.这个标签可以类比为关系数据库中的表名 创建节点.关系 创建节点(小明):create ...

  5. expect的模式

    expect的模式其实就是对话模式: expect    # 期望什么 send      # 我给你什么 比如: expect "password: "    # 碰到什么了 s ...

  6. .net Mvc Dapper 方法封装

    首先需要添加 NuGet 包 Dapper 以及引用Configuration <connectionStrings>      <add name="SqlSrc&quo ...

  7. Gym 102028J 扫描线/二维差分 + 解方程

    题意:有一个二维平面,以及n个操作,每个操作会选择一个矩形,使得这个二维平面的一部分被覆盖.现在你可以取消其中的2个操作,问最少有多少块地方会被覆盖? 思路:官方题解简洁明了,就不细说了:https: ...

  8. PHP 的 new static 和 new self

    下面我们举个例子: class Father { public static function getSelf() { return new self(); } public static funct ...

  9. Java高并发网络编程(五)Netty应用

    推送系统 一.系统设计 二.拆包和粘包 粘包.拆包表现形式 现在假设客户端向服务端连续发送了两个数据包,用packet1和packet2来表示,那么服务端收到的数据可以分为三种,现列举如下: 第一种情 ...

  10. C++ STL(一)介绍及string

    STL: C++标准模板库的简称,它是C++的一部份.标准C++库的所有的标识符都是在一个名为std的命名空间中定义的 在使用STL中相关模板时,需要包含相关头文件,然后using namespace ...