前腾讯T3人工智能大佬为你讲述：Python和人工智能入门算法

学习机器学习之前你应该了解概率，编程的基础知识，掌握java c++ c python 任意一个，还要有一定的数学基础。

基本概念

1、MachineLearning

什么是机器学习：ML（machine learning）

是一个交叉学科，涉及到计算机（软件、硬件）、概率论、统计学、线代、高数、逼近论、凸分析、机械。

通过机器学习，机器不再是通过规则行动，而是通过归纳、统计来进行结果改进。

机器不再需要外部明确的指示，而是通过经验和数据自动进行结果改进。

学习经验，针对任务，执行结果，经验越多，结果越好，则计算机有学习能力。

机器学习是AI的核心。AlphaGo实现的方法不是通过穷举法，而是通过归纳和统计，通过学习过去人类下的棋局中得到的经验，然后来确定自己的下一个棋下在什么地方。所以机器学习出现后人工智能进步了一大步。

机器学习的应用

机器学习的应用很广泛，可以用来做语音识别、自动驾驶、人脸识别、自然语言处理、推荐系统等等。

2、DeepLeaning

深度学习：DL (deep learning)

深度学习是机器学习的一个分支，以神经网络为代表的一类机器学习。比传统的机器学习效果要好很多。它模拟人脑神经的构造，利用神经元通过各种传输算法，使一个输入能产生一个比较准确的输出。

深度学习的发展是伴随大数据产生的，因为深度学习需要大量的数据进行训练，所以进行机器学习的第一步是，必须要有大量的已经存在的数据。

深度学习的基本概念

训练集(TraningSamples) ：训练机器去学习的数据

测试集(TestSamples) ：测试模型的稳定性

特征值(FeatureVector) ：通过向量代表的特征

目标概念(Lable) ：通过特征值的出来的结果

分类 ：目标概念为已知类别

回归 ：目标概念为连续值

监督学习 ：样本有类别标记

无监督学习 ：样本无类别标记

常用算法

机器学习的算法有很多很多，想全部掌握有点难。下面是几个比较常用的算法。

监督学习：

分类 ：KNN （K个nearest neighbors）、DT(Decision Tree)决策树、SVM(surpport vector machine) 、NN(nerual network) 神经网络、NB(naive bayes)贝叶斯

回归 ：LR（Linear Regression）、NLR (Non-Regression)

非监督学习：

​非监督学习算法：K-Means

机器学习的基本步骤

1、获取数据

包括数据获取、清洗、存储

2、数据拆分训练集和测试集。

3、用特征向量训练算法

4、在测试集上评估算法

5、算法迭代与改进

6、实际应用

7、获取更多数据，进行机器学习。

KNN算法

KNN是用未知和已知进行比对。假如我们有一堆的已经分好类的数据，就像一堆分好颜色的豆子。如果我们找到某颗豆子，要知道这颗豆子是什么颜色，当然人眼一看就知道，要让计算机来算的话，最简单的算法就是KNN。

KNN是把离他最近的邻居找出来，比如把离他最近的5个点找出来，然后看这5个点大多数 属于哪一类，就把它归于那个类里。

KNN算法举例

举一个简单的例子：给出一组花的数据，判断它属于哪种花。

样本 ：

网上有很多可以用的数据库，这里用的：wiki/lris_flower_data_set

特征值：萼片长度、萼片宽度、花瓣长度、花瓣宽度

label：setosa versicolor virginica （花的种类）

#首先安装类库science hit learning机器学习类库

from sklearn import neighbors

from sklearn import datasots

#取得KNN分类算法

knn = neightbors.KNeighborsClassifier()

#加载数据

iris = datasets.load_iris()

#打印数据

#print(iris)

#用KNN进行数据集的学习

knn.fit(iris.data,iris.target)

#预测输入数据集属于哪一类

predicteLabel = knn.predict([[0.1,0.2,0.3,0.4]])

#打印预测结果

print(predicteLabel)

神经网络的概念和基本算法

神经网络是模拟人类脑细胞的神经元做出的一种算法。

当人看到一个东西时，他其实在脑神经中看到的是一些特征。比如看到一只猫，看到的是它的耳朵是什么样的、眼睛是什么样的、尾巴是什么样的，等等一系列的特征值。

这些特征值在人的脑细胞中，会输入到各个神经元中，神经元再经过大量的运算，最终判断这是一只猫。

神经网络就是模拟大脑认识事物的过程。

1、把大量的特征输入到输入层。

2、中间经过大量计算的是隐藏层（隐藏层可以有多层）

3、输出最终结果的是输出层。

4、每层神经元都和下一层神经元的每个神经元相互连接，每条连接都有一个权重值 w 。

5、每个神经元上都有一个用来调整的值，叫做偏置。

所以每个神经元中的数字，是由上一层神经元存的数字、权重值、偏置，这3个值来决定的。

NN算法：

Back Propgation 后向传播，后向传播有两个过程，正向计算和反向计算。

正向计算过程：

1、特征向量标准化normalize（转化为0-1之间的值）

2、随机初始化权重和偏置（-1 ---- 1）

3、传入样例

4、计算神经元的值

对上层输入加权求和

加上偏置值

用激励函数产生最后的结果（sigmoid function）

S_j=\sum_{i=0}^{m-1}\omega_{ij}x_i+b_j

Sj

​=i=0

∑

m−1

​ωij

​xi

​+bj

​

x_j=f(S_j)

xj

​=f(Sj

​)

反向计算过程

反向计算用来调整权重和偏置。训练神经网络就是不断的调整权重和偏置的过程。

1、根据误差反向传送

2、误差计算

输出层Err=（结果）（1-结果）（预期值-结果）

举例：计算结果是0.7，正确值是0。

输出层Err=(0.7)(1-0.7)(0-0.7)

输出层Err=(0.7)(1−0.7)(0−0.7)

隐藏层Err=（结果）（1-结果）（后一层Err加权求和）

权重更新

偏置更新

一个正向过程和一个反向算一个epoch，当训练足够多的次数，正确率到一定的值时，训练就可以终止了。

一个简单的神经网络计算过程：

手写神经网络训练数字识别：

import numpy as np

from sklearn.datasets import load_digits

from sklearn.metrics import classification_report

from sklearn.preprocessing import LabelBinarizer

from sklearn.cross_validation import train_test_split

#定义激励函数

def logistic(x):

return 1/(1+np.exp(-x))

#定义激励函数导数

def logistic_derivative(x):

return logistic(x)*(1-logistic(x))

class NeuralNetWork:

#构造方法，其中layers类似于[5,10,2]

def __init__(self,layers):

self.weights=[]

for i in range(1,len(layers)-1):

self.weights.append((2*np.random.random((layers[i-1] + 1,layers[i] + 1)) - 1) * 0.25)

self.weights.append((2*np.random.random((layers[i] + 1, layers[i + 1])) - 1) * 0.25)

def fit(self, X, y, learning_rate=0.2, epochs=10000):

X=np.atleast_2d(X)

temp = np.ones([X.shape[0], X.shape[1] + 1])

temp[:, 0:-1]=X #加入偏置值

X = temp

y = np.array(y)

for k in range(epochs):

i = np.random.randint(X.shape[0])

a = [X[i]]

for l in range(len(self.weights)):

a.append(logistic(np.dot(a[1], self.weights[1])))

error = y[i] - a[-1]

deltas = [

error * logistic_derivative(a[-1])

]

#BP

for l in range(len(a) -2, 0, -1):

deltas.append(deltas[-1].dot(self.weights[1].T) * logistic_derivative(a[1]))deltas.reverse()

for i in range(len(self.weights)):

layer = np.atleast_2d(a[i])

delta = np.atleast_2d(deltas[i])

self.weights[i] += learning_rate * layer.T.dot(delta)

def predict(self, x):

x = np.array(x)

temp = np.ones(x.shape[0] + 1)

temp[0:-1] = x

a = temp

for l in range(0, len(self.weights)):

a = logistic(np.dot(a, self.weights[1]))

return a

import pylab as pl

digits = load_digitsa()

print(digits.data.shape)

```

#显示其中的一张图

pl.gray()

pl.matshow(digits.images[500])

pl.show()

```

X = digits.data

y=digits.target

X - = X.min() #把输入值映射到0-1

X / = X.max()

nn=NeuralNetwork([64,100,10])

X_train, X_test,y_train,y_test = train_test_split(X, y)

labels_train = LabelBinarizer().fit_transform(y_train)

labels_test = LabelBinarizer().fit_transform(y_test)

print("start fitting")

#训练模型

nn.fit(X_train,labels_train,epochs=1000)

predictions = []

for i in range(X_test.shape[0]):

#预测测试集

o=nn.predict(X_test[i])

predictions.append(np.argmax(o))

correct=0

for i in range(len(y_test)):

if(predictions[i]==y_test[i]):

correct += 1

print("准确率：",correct/float(len(y_test))*100,"%")

运行结果：

(1797, 64)

start fitting

准确率：94.888888888889 %

我们也可以适当的调整训练次数，步长，学习率。

Tensorflow

Tensorflow是谷歌开源大机器学习框架，下面用tensorflow实现一个，两层的神经网络，识别手写数字。

from tensorflow.examples.ttutorials.mnist import input_data

import tensorflow as tf

print('start')

mnist = input_data.read_data_sets('MNIST_data/',one_hot=Ture)

print('go on')

#定义输入向量

x = tf.placeholder(tf.float32, [None, 784])

#权重

W = tf.Variable(tf.zeros([784, 10]))

#偏置

b = tf.Variable(tf.zeros([10]))

#激励函数

y = tf.n.softmax(tf.matmul(x, W) + b)

#输出值

y_ = tf.placeholder(tf.folat32, [None, 10])

#损失函数

cross_entropy = tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(y), reduction_indices=[1]))

#用学习率最小化损失函数

train_step = tf.train.GradienttDescentOptimizer(0.9).minimize(cross_entropy)

#创建session

sess = tf.InteractiveSession()

#初始化

tf.global_variables_initializer().run()

#训练200次

for _ in range(200):

batch_xs, batch_ys = mnist.train.next_batch(100)

sess.run(train_step, feed_dict={x: batch_xs, y_: batch_ys})

correct_prediction = tf.equal(tf.argmax(y,1), tf.argmax(y_,1))

accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

print(sess.run(accuracy, feed_dict={x: mnist.test.images, y_: mnist.test.labels})

可以通过调节训练次数和batch，提高神经网络的正确率。

卷积神经网络CNN

主要用在图像识别和自然语言处理中，并且卷积神经网络的计算效率更高。

原理：先把图片转换成一个2d的图层，然后用一个卷积盒一部分一部分的读取数据，每读到一个数据就交给一个神经元。

比如有一个28*28像素的图片，先用5 * 5 像素的卷积盒，每读取一块就交给一个神经元处理。

在2828像素中用5 * 5 像素的卷积盒可以产生2424个神经元。每个神经元要处理的输入是5 * 5，所以每个神经元要处理的权重和偏置是25个，比全连接中28 * 28少很多。

如果只用一层24 * 24的特征值是不够的，所以我们可以用32层来处理不同的特征值，这一层叫做卷积层，由此可以想象这个神经元就变成了一个立体的神经元。当然不一定是32层，这是一个经验值，可以调整。

经过卷积盒生成卷积层后，卷积层的神经元要经过归一或者收敛的过程，总而言之是把上一层的结果简单的向下一层传递，这个过程叫做池化。

池化后，再增加一个全连接层，让池化层的每个神经元和全连接层的每个神经元连接。

最后计算出一个输出。

另外，池化后可以再卷积，卷积后可以再池化，最终的池化层和一个或几个全连接层连接输出结果。

tensorflow卷积神经网络代码举例：

form tensorflow.examples.tutorials.mnist import input_data

mnist = input_data.read_data_sets('MNIST_data', one_hot=True)

import tensorflow as tf

#输入层

x = tf.placeholder("float", shape=[None, 784])

#输出层

y_ = tf.placeholder("float", shape=[None, 10])

#把矩阵拆成28*28像素

x_image = tf.reshape(x, [-1,28,28,1])

print("x_image-")

print(x_image)

#定义权重

def weight_variable(shape):

initial = tf.truncated_normal(shape, stddev=0.1)

return tf.Variable(initial)

#定义偏置

def bias_variable(shape):

initial = tf.constant(0.1, shape=shape)

return tf.Variable(initial)

#做乘积

def conv2d(x, W):

return tf.nn.conv2d(x, W, strides=[1,1,1,1], padding='SAME')

#池化层

defmax_pool_2x2(x):

return tf.nn.max_pool(x, ksize=[1,2,2,1], strides=[1,2,2,1], padding='SAME')

#定义卷积层 32层

W_conv1 = weight_variable([5,5,1,32])

#定义偏置

b_conv1 = bias_variable([32])

h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1)

h_pool1 = max+pool_2x2(h_conv1)

#定义池化层

w_conv2 = weight_variable([5,5,32,64])

b_conv2 = bias_variable(64)

h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)

h_pool2 = max_pool_2x2(h_conv2)

#全连接

W_fc1 = weight_variable([7*7*64, 1024])

b_fc1 = bias_variable([1024])

h_pool2_flat = tf.reshape(h_pool2, [-1, 7*7*64])

h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)

keep_prob = tf.placeholder("float")

h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)

#输出层

W_fc2 = weight_variable([1024, 10])

b_fc2 = bias_variable([10])

y_conv = tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2) + b_fc2)

#定义损失函数

cross entropy = -tf.reduce_sum(y_*tf.log(y_conv))

#训练损失函数

train_step = tf.train.AdamOptimizer(le-4).minimize(cross_entropy)

correct_prediction = tf.equal(tf.argmax(y_conv,1), tf.argmax(y_,1))

accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))

sess = tf.Session()

sess.run(tf.initialize_all_variables())

for i in range(150):

batch = mnist.train.next_batch(20)

if i%20 == 0:

train_accuracy = sess.run(accuracy,feed_dict={x:batch[0], y_:batch[1], keep_prob:1.0})

print("step %d, training accuracy %g"%(i, train_accuracy))

sess.run(train_step,feed_dict={x:batch[0],y_:batch[1],keep_prob:0.5})

print("test accuracy %g"% sess.run(accuracy, feed_dict={

x:mnist.test.images, y_:mnist.test.labels, keep_prob: 1.0}))

基于人工智能的贝叶斯分类算法

贝尔斯算法的应用:

1.百度实时路况

2.腾讯新闻分类

3.数据清洗:数据补全

4.数据归类

5.垃圾邮箱

什么是贝尔斯算法

贝尔斯算法就是贝叶斯所研究的逆向概率: 给出一个条件,根据这个条件来推测某一个事件

例子:有一黑盒里面有若干个白球和黑球,当我们取出一个或几个球之后,

观察这些球的颜色,推断出黑白球的比例

通过一些信息推出未知的信息,这就是逆向概率

朴素贝叶斯算法就是应用先前事件的有关数据来估计未来事件发生的概率

根据例题推导贝叶斯分类算法

一所学校中有60%的男生,40%女生.男生全部穿长裤,女生一半穿长裤一半穿短裙,随机挑选一个学生,穿长裤的概率是多少?

假设 学校有U个人,

P(男生)=60%

P(女生)=40%

P(长裤|男生)=100%

P(长裤|女生)=50%

首先我们正向算一下穿长裤的总人数和穿裙子的总人数:

穿长裤人数=U*P(男生)*P(长裤|男生):U*60\%*100\% + U*P(女生)*P(长裤|女生):U*40\%*50\%=0.8U

穿长裤人数=U∗P(男生)∗P(长裤∣男生):U∗60%∗100%+U∗P(女生)∗P(长裤∣女生):U∗40%∗50%=0.8U

穿裙子的总人数=U-0.8U=0.2U

穿裙子的总人数=U−0.8U=0.2U

如果你只能看见她/他穿的是长裤,但不知道他/她的性别,你能推断出他/她是男生的概率么?

那么女生长裤该怎么计算呢

首先我们先计算出该学校中所有穿长裤的人数

U*P(男生)*P(长裤|男生)+U*P(女生)*P(长裤|女生)

U∗P(男生)∗P(长裤∣男生)+U∗P(女生)∗P(长裤∣女生)

然后我们在算出所有穿长裤的女生

U*P(女生)*P(长裤女生)

U∗P(女生)∗P(长裤女生)

用所有穿长裤的女生/所有穿长裤的人

P(长裤|女生)=U*P(女生)*P(长裤|女生)/U*P(男生)*P(长裤|男生)+U*P(女生)*G(长裤|女生)

P(长裤∣女生)=U∗P(女生)∗P(长裤∣女生)/U∗P(男生)∗P(长裤∣男生)+U∗P(女生)∗G(长裤∣女生)

然后进行公式代换并简化,假设

男生=A

女生=B

长裤=C

P(B|C)=P(B)*P(C|B)/(P(A)*P(C|A)+P(B)*P(C|B))

P(B∣C)=P(B)∗P(C∣B)/(P(A)∗P(C∣A)+P(B)∗P(C∣B))

简化:在之前公式中将U约掉,表示所有穿长裤的人可以直接用**P©来表示,用P(BC)**来表示所有穿长裤的女生

简化后公式:

P(B|C)=P(BC)/P(C)

P(B∣C)=P(BC)/P(C)

进行公式变换

P(AB)=P(B|C)*P(C)

P(AB)=P(B∣C)∗P(C)

“|” 左边代表的条件,右边代表的是在这个条件下发生的概率,P(AB)代表的是同时发生的概率

然后我们在进行转换:

P(C)*P(B|C)=P(CB)=P(B)*P(C|B)

P(C)∗P(B∣C)=P(CB)=P(B)∗P(C∣B)

既然P©*P(B|C)=P(B)*P(C|B),在将公式进行变换

P(C|B)=P(C)*P(B|C)/P(B)

P(C∣B)=P(C)∗P(B∣C)/P(B)

最后这个公式就是我们推导出来的贝叶斯公式

P(A|B)=\frac{P(B|A)P(A)}{P(B)}

P(A∣B)=P(B)

P(B∣A)P(A)

​

基于贝叶斯算法的邮件分类

陈述:100封邮件,80封正常,20封垃圾邮件

问题:1.当接收到一封新的含有"Viagra"这个词的邮件,这封邮件是垃圾邮件的概率

查看分析图:01

首先我们要知道算的Viagra在垃圾邮件中的概率,即P(垃圾邮件|Viagra)

然后代入贝叶斯公式中

P(spam|Viagra)=\frac{P(Viagra|spam)P(spam)}{P(Viagra)}

P(spam∣Viagra)=P(Viagra)

P(Viagra∣spam)P(spam)

​

在这个公式左边为 后验概率 公式右边为 先验概率

02

根据概率表将数据套入公式之中

P(垃圾邮件|Viagra)=P(Viagra|垃圾邮件)P(垃圾邮件)/P(Viagra)=(4/20)(20/100)/(5/100)=0.8

得出是垃圾邮件的概率是0.8

这种情况下,我们只考虑的了一个单词,如果包含多个单词,该如何计算:

2.如果一封邮件中,含有W1,W4这个单词,但没有出现W2,W3这俩个单词,求这是垃圾邮件的概率

根据问题推出公式

但是在概率表中发现,没有符合分母的这种情况,该如何解决?

有句话是这么说的:*如果俩个事件是相互独立的,那么就可以写为P(AB)=P(A)P(B),前提是这俩个事件是相互独立的.

而分母的这种情况,正好符合上述情况,那么就可以写为:

P(w1)*P(!w2)*P(!w3)*P(w4)

P(w1)∗P(!w2)∗P(!w3)∗P(w4)

分子类比分母也可以这么写

最后变化后的公式:

然后我们将数据代入公式

分母相同可将它约掉，垃圾邮件的总似然为：

(4/20)*(10/20)*(20/20)*(12/20)*(20/100)=0.012

(4/20)∗(10/20)∗(20/20)∗(12/20)∗(20/100)=0.012

在这种情况下6:7

非垃圾邮件的总似然为：

(1/80)*(66//80)*(71/80)*(23/80)*(80/100)=0.002

(1/80)∗(66//80)∗(71/80)∗(23/80)∗(80/100)=0.002

这种情况下是1:7

计算出来后,它们比值为6:1

6:7约等于为85.7%,是垃圾邮件的概率为85.7%

3.假设一封邮件中,包含了w1,w2,w3,w4这4个单词,该如何计算这是垃圾邮件的概率

代入贝叶斯公式中

P(spam|w1,w2,w3,w4)=\frac{P(w1,w2,w3,w4)*P(spam)}{P(w1,w2,w3,w4)}

P(spam∣w1,w2,w3,w4)=P(w1,w2,w3,w4)

P(w1,w2,w3,w4)∗P(spam)

​

然后我们在把数据代入公式中计算,先算分子

P(w1|spam)*P(w2|spam)*P(w3|spam)*P(w4|spam)

P(w1∣spam)∗P(w2∣spam)∗P(w3∣spam)∗P(w4∣spam)

当我们在计算时发现W3出现的概率是0,那么这个公式的结果就是0,但是这就成为了一个必然事件,仅仅因为W3的概率,而否定所有其他情况,那么这个结论就是不准确的.

这时,我们就需要拉普拉斯估计来解决这个问题.

拉普拉斯估计:

拉普拉斯估计本质上是给频率表中的每一个计数加一个较小的数,这样就避免了每一个类中每个特征发生概率为零的情况.

明白了拉普拉斯估计,然后代入到问题当中:

在添加4封垃圾邮件,每一封垃圾邮件中只包含一个单词.当我们添加4封垃圾邮件后,还要在添加16封正常邮件,

因为在表中可以看出,垃圾邮件和正常邮件的比值是4:1,所以我们要同比的添加16封正常邮件

然后,我们把改变后的值在代入公式当中进行计算

垃圾邮件的似然为:

(5/24)*(11/24)*(1/24)*(13/24)*(20/108)=0.0004

(5/24)∗(11/24)∗(1/24)∗(13/24)∗(20/108)=0.0004

非垃圾邮件的似然为:

(2/84)*(15/84)*(9/84)*(24/84)*(80/100)=0.0001

(2/84)∗(15/84)∗(9/84)∗(24/84)∗(80/100)=0.0001

使用拉普拉斯估计后 垃圾邮件的概率为80%，是非垃圾邮件的概率为20%

使用Python来进行测试

在运行之前需要添加一个sklearn模块,在PyCharm中的settings中的Plugins中搜索

sklearn并进行安装

截取部分代码

from skearn naive_bayes import MultinomialNB #sklearn模块

from sklearn feature_extraction.text import CountVectorizer

# 读取文本构建语料库

corpus = []

labels = []

courpus_test = []

labels_test = []

f = codecs.open("d:/sms_spam.txt", "rb") #读取数据集

count = 0

while True:

line = f.readline()

if count == 0:

count = count +1

continue

if line:

count = count +1

line = line.split(",")

lable = line[0]

sentence = line[1]

if count > 5550: #训练数据集次数,总共是5560条数据,拿5550条进行训练,剩下10条来进行测试

corpus_test.append(sentence)

if "ham"==label:

labels_test.append(0) #0表示正常,1表示垃圾邮件

elif "spam"==label:

labels_test.append(1)

else

corpus.append(sentence)

if"ham" == label:

labels.append(0)

elif "spam" == label:

labels.append(1)

else :

break

vectorizer=CounVectorizer()

fea_train = vectorizer

vectorizer=CountVectorizer()

fea_train = vectorizer.fit_transform(corpus)

print vectorizer.get_feature_names()

print fea_train.toarray()

#

vectorizer2=CountVectorizer(vocabulary=vectorizer.vocabulary_)

fea_test = vectorizer2.fit_transform(corpus_test)

# print fea_test

print fea_test.toarray()

# print vectorizer2.get_feature_names()

#create the Multinomial Naive Bevesian Classifire 朴素贝叶斯

clf = MultinomialNB(alpha = 1) #这里用到拉普拉斯估计,给每一个值加一个较小的数,一般为1

#clf就是模型 这个模型中就保存着一个概率表

clf.fit(fea_train.labels) #将训练数据传过来

#predict()就是根据贝尔斯算法来计算

pred = clf.predict(fea_test) #预测,将训练数据传进去

for p in pred:

if p == 0: #如果预测出来为0,则是正常邮件,否则为垃圾邮件

print ("正常邮件")

else:

print ("垃圾邮件")

然后我们来执行,查看结果

04

然后和数据集进行对比,发现只有10%的错误率,正确率达到了90%,一般来说一个模板达到80%以上就可以进行使用.

2018-2019年，互联网寒冬突如其来，许多IT从业者遭遇降薪、裁员、找工作难等问题。

程序员作为曾经备受羡慕的高薪群体，如今也面临着“保饭碗”的巨大压力，许多想要入坑的新人也处于观望态势。

几年前，只要有一定编程能力，就能顺利找到工作，而且每跳槽一次，工资就能飞涨。

然而今时不同往日，除了编程能力外，行业资历、项目实战经验、新技术的掌握等，也成为制约程序员等技术人跳槽加薪、稳固根基的门槛，人才竞争可谓异常激烈！

互联网“寒冬”真的来临了吗？

答案是：并没有！

“寒冬”仅存在于 Java、C、PHP、Android、IOS、数据库、.Net 等部分传统编程语言、或门槛不高的IT领域内。

当下AI人工智能等新技术处在时代风口，此类的技术人才，依然一将难求！随着AI进入落地应用的大爆发时期，企业用人需求也将全面爆发！

目前从事AI相关工作,起薪至少20K

有经验者年薪高达50-100万,极度缺人

01

入行人工智能从何开始？

为什么这些AI岗位如此抢手？

从事AI工作又需要哪些技术储备？

如何才能快速入门人工智能？

小编从招聘网站上调研多次，整理了一份人工智能工程师必备技能图谱，为想要转型或提升的小伙伴们，提供一些学习上的借鉴和参考。

很多人都想要进入人工智能领域，其实人工智能的核心就是机器学习和深度学习。

而掌握这两项技术还需要具备Python编程和高数的基础作为支撑，虽然看似有一定难度，但是并不可怕。

如果你还苦于不知如何下手？

那就继续往下看吧！

小编整理了一套由多位资深AI领域大牛精心打造，汇集多年实战经验&前沿AI项目案例的人工智能+Python系列入门视频教程，堪称入门神器！

但，这不是重点！重点是：完！全！免！费！
人工智能系列入门教程，转发+关注小编，+小编W X ①⑦⑧③⑤零⑥⑧⑤⑦⑥ 来拿走吧！