本文主要是介绍人工智能------＞第三天，进行数据转换的时刻，Tensorflow，常见的机器学习算法，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

什么时候需要、能够进行数据的转换

    训练前转换
        ->适合静态模型：即模型不会随着用户数据的变化而变化
        优势：
            数据的转换并不会影响模型的使用
            当数据转换的算法发生更改时，不会影响模型的重新训练
        缺点：
            不能解决模型随用户数据变化的需求
            当数据转换的算法发生更改时，需要重新将所有数据进行重新转换
    训练时转换
        ->适合动态模型：即模型会随着用户数据的变化而变化
        优势：
            可以解决模型随用户数据变化的需求
            当数据转换的算法发生更改时，不需要重新对所有数据进行转换
        缺点：
            数据的转换耗时时，模型的使用会受影响

    离线模型------>静态模型--------->离线训练
    在线模型------>动态模型--------->在线训练

TensorFLow

    google提供的一个开源的人工智能/深度学习SDK
            TensorFLow------------------>训练
            TensorFlow Lite------------->测试

    2.tensorflow的安装：
    pip install tensorflow==1.8.0 -i https://mirrors.aliyun.com/pypi/simple/

    tensorflow的使用：
        tensorflow使用的数据全是，张量。(矢量)        

例子：   

            import tensorflow as tf

            hello = tf.constant("Hello, TensorFlow")
            print(hello)
            sess = tf.Session()
            print(sess.run(hello))

        如果想通过tensorflow构造一个张量，必须通过tf.constant()方法，
        而且使用张量的过程，必须实在tensorflow会话中完成的，
        如果想要使用sess.run(遍历名)

        使用tensorflow实现两个整数的加法：        

import tensorflow as tf

#tf.constant():根据一个常量来构造一个Tensor(张量)
a = tf.constant([3,4,5,6,7])
b = tf.constant(4)
c = tf.add(a,b)
print(c)
'''
with tf.Session() as sess:
    print(sess.run(a+b))
    print(sess.run(a-b))
'''

print(a)

sess = tf.Session()
print(sess.run(c))
mytest = tf.summary.FileWriter("log",sess.graph)
sess.close()

        tensorflow会话中加入下面的语句：
            summary_write = tf.summary.FileWriter("log", sess.graph)
            查看tensorflow执行过程：
                tensorboard --logdir="log"
        执行后，会返回一个url，将url拷贝到浏览器中，就可以查看

常见的机器学习算法

    1.KNN

        K近邻算法：这是一个分类算法(最常用作二分类)

        算法思想：寻找距离测试点最近的K(奇数)个数据，然后对这K个数据进行类别统计，个数最多的类别即为测试点的类别。

        理解为：近朱者赤近墨者黑

    如何区分黑心菊和向日葵的区别

                        黑心菊             向日葵
        植株高度         80-100cm         100-350cm
        花径             10-15cm          10-30cm

        hxj = [
            [88, 13],
            [90, 12],
            [82, 15],
            [93, 10],
            [95, 11],
            [99, 13],
            [83, 10]
            ]

        xrk = [
            [102, 13],
            [190, 18],
            [120, 15],
            [140, 20],
            [180, 18],
            [320, 27],
            [210, 22]
            ]

    如何求距离：
        即求该点到训练集所有点的距离
            在平面坐标系中，如何求两点之间的距离：
                a: x1,y1
                b: x2,y2

                a和b之间的距离：
                    sqrt((x1-x2)**2 + (y1-y2)**2)

                for x in train_data:
                    sqrt((x[0]-t[0])**2 + (x[1]-t[1])**2)
    对所有距离排序：
    获得前奇数个(K)距离最近的点的下标
    得到距离最近的K个点的类别
    对类别进行统计，得到个数最多的类别

    KNN的流程：
        1.获得转换后的训练集和测试集
        2.计算测试集到训练集所有数据的距离
        3.找出前奇数个距离最近的点
        4.统计前奇数个点的标签和对应的个数
        5.返回个数最多的标签

import numpy as np
import matplotlib.pyplot as plt
'''
    使用Counter是用来统计的
'''
from collections import Counter 

#创建训练集，训练集一共14元素，前7个为黑心菊的数据，后7个为向日葵的数据
#每一个数据(植株高度(cm),花径(cm))
Train_data = [
            [88, 13],
			[90, 12],
			[82, 15],
			[93, 10],
			[95, 11],
			[99, 13],
			[83, 10],
            [102, 13],
			[190, 18],
			[120, 15],
			[140, 20],
			[180, 18],
			[320, 27],
			[210, 22]
]
#训练集的标签（0代表黑心菊，1代表向日葵）
train_label = [0,0,0,0,0,0,0,1,1,1,1,1,1,1]

#为了在matplotlib上显示数据特点，需要将其转换为np.ndarray
mytrain_data = np.array(Train_data)
mylb = np.array(train_label)

#print(mytrain_data[mylb==0,0])
#绘制数据特征图
plt.title("myknn")
#使用散点图显示黑心菊的数据
    #arr_name[arr1_name==xx,0]:获取arr_name数组中，下标同mylb数组中元素内容为0的元素的0号元素
plt.scatter(mytrain_data[mylb==0,0],mytrain_data[mylb==0,1],label="hxj")
#使用散点图显示向日葵的数据
plt.scatter(mytrain_data[mylb==1,0],mytrain_data[mylb==1,1],label="xrk")
#显示测试点(测试集)
x_test = [120,17]
plt.scatter(x_test[0],x_test[1],label="test-point")
plt.legend()

mydist = []
#计算测试点到所有点的欧式距离
for x in mytrain_data:
    mydist.append(np.sqrt(np.sum((x-x_test)**2)))
#将算出来的距离转为np.ndarray
mydit = np.array(mydist)

#使用下标排序的方法，获取最近距离的K个元素的下标
myret = np.argsort(mydit)
print(mydit)
print(myret)
K = 5
#获取最近的K个元素的标签
myTop = mylb[myret[:K]]
print(myTop)
#统计myTop中的数据
ret = Counter(myTop)
#获取统计结果
print(ret.most_common(),type(ret.most_common()))
#输出测试点的分类
print(x_test,"class is:",ret.most_common()[0][0],end=" ")
plt.show()

    KNN的使用：常用于简单的二分类(数据中特征值的维度不能过高)

    KNN的缺陷：
        1.算法有不可解释型
        2.容易产生维度灾难
        3.容易产生计算灾难

    KNN的特点：
        没有训练过程，或者说，训练过程就是，记录训练集和标签的数据

2.线性回归

    预测一个值的问题
    即研究一个线性问题，即测试集和预测出的值呈现一定的线性关系，而我们要研究的就是如何推断出这个关系。
    即通过离散的点之间的规律拟合出一条极为接近的线性关系。

    一元线性回归的算法思想：
        我们发现模型呈现斜截式的规律，即： y = K * x + B
        我们的要求是求出最优的K和B     

import numpy as np
import matplotlib.pyplot as plt

#y = 3x + 4

k = 3
b = 4

tr_x = np.random.uniform(0,40,100)
tr_y = tr_x * k + b
#print(tr_x)
#print(tr_y)

train_data = []
for i in range(tr_x.size):
    train_data.append([np.random.normal(tr_x[i],2),np.random.normal(tr_y[i],2)])

#print(train_data)
mytrain_data = np.array(train_data).reshape(-1,2)

#求xmean ，ymean
xmean = np.mean(mytrain_data[:,0])
ymean = np.mean(mytrain_data[:,1])
print(xmean,ymean)
#求k
    #求k的分子
fz = np.sum((mytrain_data[:,0] - xmean)*(mytrain_data[:,1] - ymean))
print(fz)
    #求k的分母
fm = np.sum((mytrain_data[:,0] - xmean)**2)
print(fm)
k = fz / fm
print(k)

#求b
b = ymean - k * xmean
print(b)

xp = np.arange(0,40)
yp = k * xp + b
#print(mytrain_data)
plt.title("MY-Liner")
plt.scatter(mytrain_data[:,0],mytrain_data[:,1],label="train_point")
plt.plot(tr_x,tr_y,color="red",label="random-liner")
plt.plot(xp,yp,color="yellow",label="model-liner")
plt.legend()
plt.show()

这篇关于人工智能------＞第三天，进行数据转换的时刻，Tensorflow，常见的机器学习算法的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！