1. 人工智能与 Python——启发式搜索
2. 人工智能与 Python – 游戏
3. 人工智能与 Python——神经网络
4. 强化学习
5. 人工智能与 Python——遗传算法
6. 人工智能与 Python——计算机视觉
7. 人工智能与 Python——深度学习
人工智能与 Python——启发式搜索
启发式搜索在人工智能中起着关键作用。在本章中，您将详细了解它。
人工智能中启发式搜索的概念
启发式是一种经验法则，它引导我们找到可能的解决方案。人工智能中的大多数问题都是指数性质的，并且有许多可能的解决方案。您不确切知道哪些解决方案是正确的，并且检查所有解决方案将非常昂贵。
因此，启发式的使用缩小了对解决方案的搜索范围并消除了错误的选择。在搜索空间中使用启发式引导搜索的方法称为启发式搜索。启发式技术非常有用，因为使用它们可以提高搜索速度。
不知情搜索和知情搜索之间的区别
有两种类型的控制策略或搜索技术：不知情的和知情的。它们在此处详细解释 -
不知情的搜索
也称为盲目搜索或盲目控制策略。之所以这样命名，是因为只有关于问题定义的信息，没有关于状态的其他额外信息。这种搜索技术将搜索整个状态空间以获得解决方案。广度优先搜索 (BFS) 和深度优先搜索 (DFS) 是不知情搜索的示例。
知情搜索
也称为启发式搜索或启发式控制策略。之所以这样命名是因为有一些关于状态的额外信息。此额外信息可用于计算子节点之间探索和扩展的偏好。每个节点都有一个启发式函数。最佳优先搜索 (BFS)、A*、均值和分析是知情搜索的示例。
约束满足问题 (CSP)
约束意味着限制或限制。在人工智能中，约束满足问题是必须在某些约束条件下解决的问题。在解决此类问题时，重点必须放在不违反约束上。最后，当我们得出最终解时，CSP 必须服从约束。
通过约束满足解决现实世界问题
前面的部分涉及创建约束满足问题。现在，让我们也将其应用于现实世界的问题。约束满足解决的现实世界问题的一些例子如下 -
求解代数关系
借助约束满足问题，我们可以解决代数关系。在这个例子中，我们将尝试求解一个简单的代数关系a*2 = b。它将在我们定义的范围内返回a和b的值。
完成此 Python 程序后，您将能够了解解决约束满足问题的基础知识。
请注意，在编写程序之前，我们需要安装名为 python-constraint 的 Python 包。您可以借助以下命令安装它 -
pip install python-constraint
以下步骤向您展示了一个使用约束满足来求解代数关系的 Python 程序 -
使用以下命令导入约束包 -
from constraint import *
现在，创建一个名为 problem() 的模块对象，如下所示 -
problem = Problem()
现在，定义变量。请注意，这里我们有两个变量 a 和 b，我们将 10 定义为它们的范围，这意味着我们在前 10 个数字内得到了解决方案。
problem.addVariable('a', range(10))
problem.addVariable('b', range(10))
接下来，定义我们要应用于此问题的特定约束。请注意，我们在这里使用约束a*2 = b。
problem.addConstraint(lambda a, b: a * 2 == b)
现在，使用以下命令创建getSolution() 模块的对象 -
solutions = problem.getSolutions()
最后，使用以下命令打印输出 -
print (solutions)
您可以观察上述程序的输出如下 -
[{'a': 4, 'b': 8}, {'a': 3, 'b': 6}, {'a': 2, 'b': 4}, {'a': 1, 'b': 2}, {'a': 0, 'b': 0}]
幻方
幻方是不同数字（通常是整数）在方格中的排列，其中每一行中的数字，每一列中的数字，以及对角线上的数字，所有加起来都是相同的数字，称为“魔术常数” .
以下是用于生成幻方的简单 Python 代码的逐步执行 -
定义一个名为 magic_square的函数，如下所示 -
def magic_square(matrix_ms):
iSize = len(matrix_ms[0])
sum_list = []
以下代码显示了正方形垂直的代码 -
for col in range(iSize):
sum_list.append(sum(row[col] for row in matrix_ms))
以下代码显示了正方形水平的代码 -
sum_list.extend([sum (lines) for lines in matrix_ms])
以下代码显示了水平正方形的代码 -
dlResult = 0
for i in range(0,iSize):
dlResult +=matrix_ms[i][i]
sum_list.append(dlResult)
drResult = 0
for i in range(iSize-1,-1,-1):
drResult +=matrix_ms[i][i]
sum_list.append(drResult)
if len(set(sum_list))>1:
return False
return True
现在，给出矩阵的值并检查输出 -
print(magic_square([[1,2,3], [4,5,6], [7,8,9]]))
您可以观察到输出将为False，因为总和不等于相同的数字。
print(magic_square([[3,9,2], [3,5,7], [9,1,6]]))
您可以观察到输出为True，因为总和是相同的数字，这里是15 。
人工智能与 Python – 游戏
游戏是有策略的。每个玩家或团队在开始游戏之前都会制定策略，他们必须根据游戏中的当前情况更改或构建新策略。
搜索算法
您还必须使用与上述相同的策略来考虑电脑游戏。请注意，搜索算法是计算计算机游戏策略的算法。
怎么运行的
搜索算法的目标是找到最优的一组移动，以便它们可以到达最终目的地并获胜。这些算法使用每场比赛不同的获胜条件集来找到最佳动作。
将电脑游戏想象成一棵树。我们知道树有节点。从根开始，我们可以到达最终的获胜节点，但采用最佳移动。那是搜索算法的工作。这种树中的每个节点都代表一个未来状态。搜索算法搜索此树以在游戏的每个步骤或节点做出决策。
组合搜索
使用搜索算法的主要缺点是它们本质上是详尽无遗的，这就是为什么他们探索整个搜索空间以找到导致资源浪费的解决方案的原因。如果这些算法需要搜索整个搜索空间来找到最终的解决方案，那就更麻烦了。
为了消除此类问题，我们可以使用组合搜索，它使用启发式来探索搜索空间并通过消除可能的错误移动来减小其大小。因此，此类算法可以节省资源。这里讨论了一些使用启发式搜索空间和节省资源的算法 -
极小极大算法
它是组合搜索使用的策略，它使用启发式来加速搜索策略。Minimax 策略的概念可以通过两个玩家博弈的例子来理解，其中每个玩家都试图预测对手的下一步行动并试图最小化该函数。此外，为了获胜，玩家总是根据当前情况尝试最大化自己的功能。
启发式在诸如 Minimax 之类的此类策略中起着重要作用。树的每个节点都有一个与之关联的启发式函数。基于该启发式，它将决定向最有利于他们的节点移动。
Alpha-Beta 修剪
Minimax 算法的一个主要问题是它可以探索树中不相关的部分，导致资源浪费。因此，必须有一种策略来决定树的哪一部分是相关的，哪一部分是不相关的，并且不探索不相关的部分。Alpha-Beta 剪枝就是这样一种策略。
Alpha-Beta 剪枝算法的主要目标是避免搜索树中没有任何解的那些部分。Alpha-Beta 剪枝的主要概念是使用两个边界，名为Alpha的最大下限和Beta的最小上限。这两个参数是限制可能解集的值。它将当前节点的值与 alpha 和 beta 参数的值进行比较，以便它可以移动到树中有解决方案的部分并丢弃其余部分。
Negamax算法
该算法与 Minimax 算法没有区别，但它有更优雅的实现。使用 Minimax 算法的主要缺点是我们需要定义两个不同的启发式函数。这些启发式之间的联系是，游戏状态对一个玩家来说越好，对另一个玩家来说就越糟糕。在 Negamax 算法中，两个启发式函数的相同工作是在单个启发式函数的帮助下完成的。
构建机器人来玩游戏
为了让机器人在 AI 中玩两个玩家游戏，我们需要安装easyAI库。它是一个人工智能框架，提供构建双人游戏的所有功能。您可以借助以下命令下载它 -
pip install easyAI
玩最后一枚硬币的机器人
在这个游戏中，会有一堆硬币。每个玩家必须从那堆中拿走一些硬币。游戏的目标是避免拿走最后一枚硬币。我们将使用从easyAI库的TwoPlayersGame类继承的类LastCoinStanding。以下代码显示了该游戏的 Python 代码 -
如图所示导入所需的包 -
from easyAI import TwoPlayersGame, id_solve, Human_Player, AI_Player
from easyAI.AI import TT
现在，从 TwoPlayerGame类继承类来处理游戏的所有操作 -
class LastCoin_game(TwoPlayersGame):
def init(self, players):
现在，定义玩家和将要开始游戏的玩家。
self.players = players
self.nplayer = 1
现在，定义游戏中的硬币数量，这里我们为游戏使用 15 个硬币。
self.num_coins = 15
定义玩家在移动中可以拿走的最大硬币数。
self.max_coins = 4
现在有一些特定的东西需要定义，如下面的代码所示。定义可能的动作。
def possible_moves(self):
return [str(a) for a in range(1, self.max_coins + 1)]
定义硬币的移除
def make_move(self, move):
self.num_coins -= int(move)
定义谁拿走了最后一枚硬币。
def win_game(self):
return self.num_coins <= 0
定义何时停止游戏，即何时有人获胜。
def is_over(self):
return self.win()
定义如何计算分数。
def score(self):
return 100 if self.win_game() else 0
定义堆中剩余的硬币数。
def show(self):
print(self.num_coins, 'coins left in the pile')
if name == "main":
tt = TT()
LastCoin_game.ttentry = lambda self: self.num_coins
使用以下代码块解决游戏 -
r, d, m = id_solve(LastCoin_game,
range(2, 20), win_score=100, tt=tt)
print(r, d, m)
决定谁将开始游戏
game = LastCoin_game([AI_Player(tt), Human_Player()])
game.play()
您可以找到以下输出和这个游戏的简单玩法 -
d:2, a:0, m:1
d:3, a:0, m:1
d:4, a:0, m:1
d:5, a:0, m:1
d:6, a:100, m:4
1 6 4
15 coins left in the pile
Move #1: player 1 plays 4 :
11 coins left in the pile
Player 2 what do you play ? 2
Move #2: player 2 plays 2 :
9 coins left in the pile
Move #3: player 1 plays 3 :
6 coins left in the pile
Player 2 what do you play ? 1
Move #4: player 2 plays 1 :
5 coins left in the pile
Move #5: player 1 plays 4 :
1 coins left in the pile
Player 2 what do you play ? 1
Move #6: player 2 plays 1 :
0 coins left in the pile
玩井字游戏的机器人
Tic-Tac-Toe 非常熟悉，也是最受欢迎的游戏之一。让我们使用Python 中的easyAI库来创建这个游戏。以下代码是这个游戏的 Python 代码 -
如图所示导入包 -
from easyAI import TwoPlayersGame, AI_Player, Negamax
from easyAI.Player import Human_Player
从 TwoPlayerGame类继承类来处理游戏的所有操作 -
class TicTacToe_game(TwoPlayersGame):
def init(self, players):
现在，定义玩家和将要开始游戏的玩家 -
self.players = players
self.nplayer = 1
定义板的类型 -
self.board = [0] * 9
现在有一些特定的东西可以定义如下 -
定义可能的动作
def possible_moves(self):
return [x + 1 for x, y in enumerate(self.board) if y == 0]
定义玩家的动作 -
def make_move(self, move):
self.board[int(move) - 1] = self.nplayer
为了提升 AI，定义玩家何时移动 -
def umake_move(self, move):
self.board[int(move) - 1] = 0
定义对手三连胜的失败条件
def condition_for_lose(self):
possible_combinations = [[1,2,3], [4,5,6], [7,8,9],
[1,4,7], [2,5,8], [3,6,9], [1,5,9], [3,5,7]]
return any([all([(self.board[z-1] == self.nopponent)
for z in combination]) for combination in possible_combinations])
定义游戏结束检查
def is_over(self):
return (self.possible_moves() == []) or self.condition_for_lose()
显示玩家在游戏中的当前位置
def show(self):
print('\n'+'\n'.join([' '.join([['.', 'O', 'X'][self.board[3*j + i]]
for i in range(3)]) for j in range(3)]))
计算分数。
def scoring(self):
return -100 if self.condition_for_lose() else 0
定义主要方法来定义算法并开始游戏 -
if name == "main":
algo = Negamax(7)
TicTacToe_game([Human_Player(), AI_Player(algo)]).play()
您可以看到以下输出和这个游戏的简单玩法 -
. . .
. . .
. . .
Player 1 what do you play ? 1
Move #1: player 1 plays 1 :
O . .
. . .
. . .
Move #2: player 2 plays 5 :
O . .
. X .
121
. . .
Player 1 what do you play ? 3
Move #3: player 1 plays 3 :
O . O
. X .
. . .
Move #4: player 2 plays 2 :
O X O
. X .
. . .
Player 1 what do you play ? 4
Move #5: player 1 plays 4 :
O X O
O X .
. . .
Move #6: player 2 plays 8 :
O X O
O X .
. X .
人工智能与 Python——神经网络
神经网络是并行计算设备，试图建立大脑的计算机模型。背后的主要目标是开发一个系统来比传统系统更快地执行各种计算任务。这些任务包括模式识别和分类、近似、优化和数据聚类。
什么是人工神经网络 (ANN)
人工神经网络 (ANN) 是一种高效的计算系统，其中心主题借鉴了生物神经网络的类比。人工神经网络也被命名为人工神经系统、并行分布式处理系统和联结系统。人工神经网络获取大量单元集合，这些单元以某种模式相互连接以允许它们之间进行通信。这些单元，也称为节点或神经元，是并行运行的简单处理器。
每个神经元都通过连接链路与其他神经元相连。每个连接链路都与一个权重相关联，该权重具有关于输入信号的信息。这是神经元解决特定问题最有用的信息，因为重量通常会激发或抑制正在传达的信号。每个神经元都有其内部状态，称为激活信号。将输入信号和激活规则组合后产生的输出信号可以发送到其他单元。
如果你想详细研究神经网络，那么你可以点击链接 -人工神经网络。
安装有用的包
为了在 Python 中创建神经网络，我们可以使用一个名为 NeuroLab的功能强大的神经网络包。它是一个基本神经网络算法库，具有灵活的网络配置和 Python 学习算法。您可以在命令提示符下借助以下命令安装此软件包 -
pip install NeuroLab
如果您使用的是 Anaconda 环境，请使用以下命令安装 NeuroLab -
conda install -c labfabulous neurolab
构建神经网络
在本节中，让我们使用 NeuroLab 包在 Python 中构建一些神经网络。
基于感知器的分类器
感知器是人工神经网络的基石。如果您想了解更多关于 Perceptron 的信息，可以点击链接 - artificial_neural_network
以下是用于构建简单的基于神经网络感知器的分类器的 Python 代码的逐步执行 -
如图所示导入必要的包 -
import matplotlib.pyplot as plt
import neurolab as nl
输入输入值。请注意，这是监督学习的示例，因此您也必须提供目标值。
input = [[0, 0], [0, 1], [1, 0], [1, 1]]
target = [[0], [0], [0], [1]]
创建具有 2 个输入和 1 个神经元的网络 -
net = nl.net.newp([[0, 1],[0, 1]], 1)
现在，训练网络。在这里，我们使用 Delta 规则进行训练。
error_progress = net.train(input, target, epochs=100, show=10, lr=0.1)
现在，可视化输出并绘制图表 -
plt.figure()
plt.plot(error_progress)
plt.xlabel('Number of epochs')
plt.ylabel('Training error')
plt.grid()
plt.show()
您可以看到下图显示使用错误度量的训练进度 -
单层神经网络
在此示例中，我们正在创建一个单层神经网络，该网络由作用于输入数据以产生输出的独立神经元组成。请注意，我们使用名为****neural_simple.txt的文本文件作为输入。
如图所示导入有用的包 -
import numpy as np
import matplotlib.pyplot as plt
import neurolab as nl
加载数据集如下 -
input_data = np.loadtxt(“/Users/admin/neural_simple.txt')
以下是我们将要使用的数据。请注意，在此数据中，前两列是特征，后两列是标签。
array([[2. , 4. , 0. , 0. ],
[1.5, 3.9, 0. , 0. ],
[2.2, 4.1, 0. , 0. ],
[1.9, 4.7, 0. , 0. ],
[5.4, 2.2, 0. , 1. ],
[4.3, 7.1, 0. , 1. ],
[5.8, 4.9, 0. , 1. ],
[6.5, 3.2, 0. , 1. ],
[3. , 2. , 1. , 0. ],
[2.5, 0.5, 1. , 0. ],
[3.5, 2.1, 1. , 0. ],
[2.9, 0.3, 1. , 0. ],
[6.5, 8.3, 1. , 1. ],
[3.2, 6.2, 1. , 1. ],
[4.9, 7.8, 1. , 1. ],
[2.1, 4.8, 1. , 1. ]])
现在，将这四列分成 2 个数据列和 2 个标签 -
data = input_data[:, 0:2]
labels = input_data[:, 2:]
使用以下命令绘制输入数据 -
plt.figure()
plt.scatter(data[:,0], data[:,1])
plt.xlabel('Dimension 1')
plt.ylabel('Dimension 2')
plt.title('Input data')
现在，定义每个维度的最小值和最大值，如下所示 -
dim1_min, dim1_max = data[:,0].min(), data[:,0].max()
dim2_min, dim2_max = data[:,1].min(), data[:,1].max()
接下来，定义输出层中的神经元数量如下 -
nn_output_layer = labels.shape[1]
现在，定义一个单层神经网络 -
dim1 = [dim1_min, dim1_max]
dim2 = [dim2_min, dim2_max]
neural_net = nl.net.newp([dim1, dim2], nn_output_layer)
如图所示，用时期数和学习率训练神经网络 -
error = neural_net.train(data, labels, epochs = 200, show = 20, lr = 0.01)
现在，使用以下命令可视化并绘制训练进度 -
plt.figure()
plt.plot(error)
plt.xlabel('Number of epochs')
plt.ylabel('Training error')
plt.title('Training error progress')
plt.grid()
plt.show()
现在，使用上述分类器中的测试数据点 -
print('\nTest Results:')
data_test = [[1.5, 3.2], [3.6, 1.7], [3.6, 5.7],[1.6, 3.9]] for item in data_test:
print(item, '-->', neural_net.sim([item])[0])
您可以找到如下所示的测试结果 -
[1.5, 3.2] --> [1. 0.]
[3.6, 1.7] --> [1. 0.]
[3.6, 5.7] --> [1. 1.]
[1.6, 3.9] --> [1. 0.]
您可以看到下图作为到目前为止讨论的代码的输出 -
多层神经网络
在此示例中，我们正在创建一个由多个层组成的多层神经网络，以提取训练数据中的底层模式。这个多层神经网络将像回归器一样工作。我们将根据等式生成一些数据点：y = 2x 2 +8。
如图所示导入必要的包 -
import numpy as np
import matplotlib.pyplot as plt
import neurolab as nl
根据上述等式生成一些数据点 -
min_val = -30
max_val = 30
num_points = 160
x = np.linspace(min_val, max_val, num_points)
y = 2 * np.square(x) + 8
y /= np.linalg.norm(y)
现在，按如下方式重塑此数据集 -
data = x.reshape(num_points, 1)
labels = y.reshape(num_points, 1)
使用以下命令可视化和绘制输入数据集 -
plt.figure()
plt.scatter(data, labels)
plt.xlabel('Dimension 1')
plt.ylabel('Dimension 2')
plt.title('Data-points')
现在，使用 neurolab构建具有两个隐藏层的神经网络，其中第一个隐藏层有10 个神经元，第二个隐藏层有6 个神经元，输出层有一个。
neural_net = nl.net.newff([[min_val, max_val]], [10, 6, 1])
现在使用梯度训练算法 -
neural_net.trainf = nl.train.train_gd
现在训练网络以学习上面生成的数据为目标 -
error = neural_net.train(data, labels, epochs = 1000, show = 100, goal = 0.01)
现在，在训练数据点上运行神经网络 -
output = neural_net.sim(data)
y_pred = output.reshape(num_points)
现在绘制和可视化任务 -
plt.figure()
plt.plot(error)
plt.xlabel('Number of epochs')
plt.ylabel('Error')
plt.title('Training error progress')
现在我们将绘制实际输出与预测输出 -
x_dense = np.linspace(min_val, max_val, num_points * 2)
y_dense_pred = neural_net.sim(x_dense.reshape(x_dense.size,1)).reshape(x_dense.size)
plt.figure()
plt.plot(x_dense, y_dense_pred, '-', x, y, '.', x, y_pred, 'p')
plt.title('Actual vs predicted')
plt.show()
作为上述命令的结果，您可以观察到如下所示的图表 -
人工智能与 Python——强化学习
在本章中，您将详细了解使用 Python 进行 AI 强化学习的概念。
强化学习基础
这种类型的学习用于根据批评信息来加强或加强网络。也就是说，在强化学习下接受训练的网络会从环境中接收一些反馈。然而，反馈是评价性的，而不是指导性的，就像在监督学习的情况下那样。基于此反馈，网络执行权重调整以获得更好的未来评论信息。
这个学习过程类似于监督学习，但我们可能拥有的信息非常少。下图给出了强化学习的框图 -
构建块：环境和代理
环境和代理是 AI 中强化学习的主要构建块。本节详细讨论它们 -
代理人
代理是任何可以通过传感器感知其环境并通过效应器作用于该环境的事物。
· 人类主体具有与传感器平行的眼睛、耳朵、鼻子、舌头和皮肤等感觉器官，以及用于效应器的其他器官，例如手、腿、嘴。
· 机器人代理取代了传感器的相机和红外测距仪，以及效应器的各种电机和执行器。
· 软件代理将位串编码为它的程序和动作。
代理术语
以下术语在 AI 的强化学习中更常用 -
· 代理人的绩效衡量标准- 这是确定代理人成功程度的标准。
· 代理行为- 这是代理在任何给定的感知序列之后执行的操作。
· Percept - 它是代理在给定实例中的感知输入。
· Percept Sequence - 这是代理人迄今为止所感知的所有历史。
· Agent Function - 它是从指令序列到动作的映射。
环境
一些程序在完全人工的环境中运行，仅限于键盘输入、数据库、计算机文件系统和屏幕上的字符输出。
相比之下，一些软件代理，例如软件机器人或软件机器人，存在于丰富且无限的软件机器人域中。模拟器有一个非常详细和复杂的环境。软件代理需要从一长串实时操作中进行选择。
例如，设计用于扫描客户在线偏好并向客户展示有趣项目的软件机器人可以在真实环境和人工环境中工作。
环境属性
环境具有多重属性，如下所述 -
· 离散 / 连续- 如果环境的不同、明确定义的状态数量有限，则环境是离散的，否则它是连续的。例如，国际象棋是一个离散的环境，而开车是一个连续的环境。
· Observable/Partially Observable - 如果可以从感知中确定每个时间点环境的完整状态，则它是可观察的；否则只能部分观察到。
· 静态 / 动态- 如果环境在代理人行动时没有改变，那么它就是静态的；否则它是动态的。
· 单一代理 / 多个代理- 环境可能包含其他代理，这些代理可能与代理的类型相同或不同。
· Accessible/Inaccessible - 如果代理的感觉装置可以访问环境的完整状态，那么该代理就可以访问环境；否则无法访问。
· Deterministic/Non-deterministic - 如果环境的下一个状态完全由当前状态和代理的动作决定，那么环境是确定性的；否则它是不确定的。
· Episodic/Non-episodic - 在情节环境中，每一集都由代理人感知然后行动组成。其动作的质量仅取决于剧集本身。后续情节不依赖于先前情节中的动作。情节环境要简单得多，因为代理不需要提前思考。
使用 Python 构建环境
为了构建强化学习代理，我们将使用OpenAI Gym包，它可以在以下命令的帮助下安装 -
pip install gym
OpenAI gym 中有各种环境，可用于各种目的。其中很少有Cartpole-v0 、 Hopper-v1和MsPacman-v0。他们需要不同的引擎。OpenAI Gym的详细文档可以在/#environments上找到。
以下代码显示了 cartpole-v0 环境的 Python 代码示例 -
import gym
env = gym.make('CartPole-v0')
env.reset()
for _ in range(1000):
env.render()
env.step(env.action_space.sample())
您可以用类似的方式构建其他环境。
使用 Python 构建学习代理
为了构建强化学习代理，我们将使用OpenAI Gym包，如图所示 -
import gym
env = gym.make('CartPole-v0')
for _ in range(20):
observation = env.reset()
for i in range(100):
env.render()
print(observation)
action = env.action_space.sample()
observation, reward, done, info = env.step(action)
if done:
print("Episode finished after {} timesteps".format(i+1))
break
观察手推车可以自行平衡。
人工智能与 Python——遗传算法
本章详细讨论了人工智能的遗传算法。
什么是遗传算法？
遗传算法 (GA) 是基于自然选择和遗传学概念的搜索算法。GA 是一个更大的计算分支的子集，称为进化计算。
遗传算法是由 John Holland 和他在密歇根大学的学生和同事开发的，最著名的是 David E. Goldberg。从那以后，它已经在各种优化问题上进行了尝试，并取得了很大的成功。
在 GA 中，我们有一个给定问题的可能解决方案池。然后这些解决方案进行重组和突变（就像在自然遗传学中一样），产生新的孩子，这个过程在不同的世代中重复。每个个体（或候选解决方案）都被分配了一个适应值（基于其目标函数值），并且更适合的个体有更高的机会交配并产生更适合的个体。这符合达尔文的适者生存理论。
因此，它不断进化出更好的个体或解决方案，直到达到停止标准。
遗传算法在本质上是充分随机的，但它们比随机局部搜索（我们只是尝试随机解决方案，跟踪迄今为止最好的解决方案）表现得更好，因为它们也利用了历史信息。
如何使用 GA 解决优化问题？
优化是使设计、情境、资源和系统尽可能有效的行动。以下框图显示了优化过程 -
优化过程的GA机制阶段
以下是用于优化问题的 GA 机制的一系列步骤。
· 第 1 步 - 随机生成初始种群。
· 第 2 步 - 选择具有最佳适应度值的初始解决方案。
· 第 3 步 - 使用变异和交叉运算符重新组合选定的解决方案。
· 第 4 步 - 将后代插入种群中。
· 第 5 步 - 现在，如果满足停止条件，则返回具有最佳适应度值的解决方案。否则转到第 2 步。
安装必要的包
为了在 Python 中使用遗传算法解决问题，我们将使用一个强大的 GA 包，称为DEAP。它是一个用于快速原型设计和想法测试的新型进化计算框架库。我们可以在命令提示符下借助以下命令安装此软件包 -
pip install deap
如果您使用的是anaconda环境，则可以使用以下命令安装 deap -
conda install -c conda-forge deap
使用遗传算法实施解决方案
本节向您解释如何使用遗传算法实施解决方案。
生成位模式
以下示例向您展示了如何根据 One Max问题生成包含 15 个 1 的位串。
如图所示导入必要的包 -
import random
from deap import base, creator, tools
定义评估函数。这是创建遗传算法的第一步。
def eval_func(individual):
target_sum = 15
return len(individual) - abs(sum(individual) - target_sum),
现在，使用正确的参数创建工具箱 -
def create_toolbox(num_bits):
creator.create("FitnessMax", base.Fitness, weights=(1.0,))
creator.create("Individual", list, fitness=creator.FitnessMax)
初始化工具箱
toolbox = base.Toolbox()
toolbox.register("attr_bool", random.randint, 0, 1)
toolbox.register("individual", tools.initRepeat, creator.Individual,
toolbox.attr_bool, num_bits)
toolbox.register("population", tools.initRepeat, list, toolbox.individual)
注册评估运营商 -
toolbox.register("evaluate", eval_func)
现在，注册交叉运算符 -
toolbox.register("mate", tools.cxTwoPoint)
注册一个变异操作符 -
toolbox.register("mutate", tools.mutFlipBit, indpb = 0.05)
定义育种操作符 -
toolbox.register("select", tools.selTournament, tournsize = 3)
return toolbox
if name == "main":
num_bits = 45
toolbox = create_toolbox(num_bits)
random.seed(7)
population = toolbox.population(n = 500)
probab_crossing, probab_mutating = 0.5, 0.2
num_generations = 10
print('\nEvolution process starts')
评估整个人口 -
fitnesses = list(map(toolbox.evaluate, population))
for ind, fit in zip(population, fitnesses):
ind.fitness.values = fit
print('\nEvaluated', len(population), 'individuals')
创建和迭代几代 -
for g in range(num_generations):
print("\n- Generation", g)
选择下一代个体 -
offspring = toolbox.select(population, len(population))
现在，克隆选定的个体 -
offspring = list(map(toolbox.clone, offspring))
对后代应用交叉和变异 -
for child1, child2 in zip(offspring[::2], offspring[1::2]):
if random.random() < probab_crossing:
toolbox.mate(child1, child2)
删除孩子的适应度值
del child1.fitness.values
del child2.fitness.values
现在，应用突变 -
for mutant in offspring:
if random.random() < probab_mutating:
toolbox.mutate(mutant)
del mutant.fitness.values
评估具有无效适应性的个体 -
invalid_ind = [ind for ind in offspring if not ind.fitness.valid]
fitnesses = map(toolbox.evaluate, invalid_ind)
for ind, fit in zip(invalid_ind, fitnesses):
ind.fitness.values = fit
print('Evaluated', len(invalid_ind), 'individuals')
现在，用下一代个体代替人口 -
population[:] = offspring
打印当前世代的统计数据 -
fits = [ind.fitness.values[0] for ind in population]
length = len(population)
mean = sum(fits) / length
sum2 = sum(x*x for x in fits)
std = abs(sum2 / length - mean**2)**0.5
print('Min =', min(fits), ', Max =', max(fits))
print('Average =', round(mean, 2), ', Standard deviation =',
round(std, 2))
print("\n- Evolution ends")
打印最终输出 -
best_ind = tools.selBest(population, 1)[0]
print('\nBest individual:\n', best_ind)
print('\nNumber of ones:', sum(best_ind))
Following would be the output:
Evolution process starts
Evaluated 500 individuals
- Generation 0
Evaluated 295 individuals
Min = 32.0 , Max = 45.0
Average = 40.29 , Standard deviation = 2.61
- Generation 1
Evaluated 292 individuals
Min = 34.0 , Max = 45.0
Average = 42.35 , Standard deviation = 1.91
- Generation 2
Evaluated 277 individuals
Min = 37.0 , Max = 45.0
Average = 43.39 , Standard deviation = 1.46
… … … …
- Generation 9
Evaluated 299 individuals
Min = 40.0 , Max = 45.0
Average = 44.12 , Standard deviation = 1.11
- Evolution ends
Best individual:
[0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1,
1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0,
1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 1]
Number of ones: 15
符号回归问题
这是遗传编程中最著名的问题之一。所有符号回归问题都使用任意数据分布，并尝试用符号公式拟合最准确的数据。通常，使用诸如 RMSE（均方根误差）之类的度量来衡量个人的健康状况。这是一个经典的回归量问题，在这里我们使用方程式5x 3 -6x 2 +8x=1。我们需要按照上面示例中的所有步骤进行操作，但主要部分是创建原始集，因为它们是个体的构建块，因此可以开始评估。在这里，我们将使用经典的原语集。
以下 Python 代码详细解释了这一点 -
import operator
import math
import random
import numpy as np
from deap import algorithms, base, creator, tools, gp
def division_operator(numerator, denominator):
if denominator == 0:
return 1
return numerator / denominator
def eval_func(individual, points):
func = toolbox.compile(expr=individual)
return math.fsum(mse) / len(points),
def create_toolbox():
pset = gp.PrimitiveSet("MAIN", 1)
pset.addPrimitive(operator.add, 2)
pset.addPrimitive(operator.sub, 2)
pset.addPrimitive(operator.mul, 2)
pset.addPrimitive(division_operator, 2)
pset.addPrimitive(operator.neg, 1)
pset.addPrimitive(math.cos, 1)
pset.addPrimitive(math.sin, 1)
pset.addEphemeralConstant("rand101", lambda: random.randint(-1,1))
pset.renameArguments(ARG0 = 'x')
creator.create("FitnessMin", base.Fitness, weights = (-1.0,))
creator.create("Individual",gp.PrimitiveTree,fitness=creator.FitnessMin)
toolbox = base.Toolbox()
toolbox.register("expr", gp.genHalfAndHalf, pset=pset, min_=1, max_=2)
toolbox.expr)
toolbox.register("population",tools.initRepeat,list, toolbox.individual)
toolbox.register("compile", gp.compile, pset = pset)
toolbox.register("evaluate", eval_func, points = [x/10. for x in range(-10,10)])
toolbox.register("select", tools.selTournament, tournsize = 3)
toolbox.register("mate", gp.cxOnePoint)
toolbox.register("expr_mut", gp.genFull, min_=0, max_=2)
toolbox.register("mutate", gp.mutUniform, expr = toolbox.expr_mut, pset = pset)
toolbox.decorate("mate", gp.staticLimit(key = operator.attrgetter("height"), max_value = 17))
toolbox.decorate("mutate", gp.staticLimit(key = operator.attrgetter("height"), max_value = 17))
return toolbox
if name == "main":
random.seed(7)
toolbox = create_toolbox()
population = toolbox.population(n = 450)
hall_of_fame = tools.HallOfFame(1)
stats_fit = tools.Statistics(lambda x: x.fitness.values)
stats_size = tools.Statistics(len)
mstats = tools.MultiStatistics(fitness=stats_fit, size = stats_size)
mstats.register("avg", np.mean)
mstats.register("std", np.std)
mstats.register("min", np.min)
mstats.register("max", np.max)
probab_crossover = 0.4
probab_mutate = 0.2
number_gen = 10
population, log = algorithms.eaSimple(population, toolbox,
probab_crossover, probab_mutate, number_gen,
stats = mstats, halloffame = hall_of_fame, verbose = True)
请注意，所有基本步骤与生成位模式时使用的相同。该程序将在 10 代之后为我们提供最小值、最大值、标准差（标准差）的输出。
人工智能与 Python——计算机视觉
计算机视觉涉及使用计算机软件和硬件对人类视觉进行建模和复制。在本章中，您将详细了解这一点。
计算机视觉
计算机视觉是一门研究如何根据场景中存在的结构属性从 2d 图像重建、中断和理解 3d 场景的学科。
计算机视觉层次结构
计算机视觉分为以下三个基本类别 -
· 低级视觉- 它包括用于特征提取的过程图像。
· 中级视觉- 包括物体识别和 3D 场景解释
· 高级视觉- 它包括对活动、意图和行为等场景的概念描述。
计算机视觉与图像处理
图像处理研究图像到图像的转换。图像处理的输入和输出都是图像。
计算机视觉是从图像中构建对物理对象的明确、有意义的描述。计算机视觉的输出是对 3D 场景中结构的描述或解释。
应用
计算机视觉在以下领域得到应用 -
机器人技术
· 定位-自动确定机器人位置
· 导航
· 避障
· 装配（钉入孔、焊接、喷漆）
· 操纵（如PUMA机械手）
· 人机交互 (HRI)：与人互动并为人服务的智能机器人
药品
· 分类和检测（例如病变或细胞分类和肿瘤检测）
· 2D/3D分割
· 3D 人体器官重建（MRI 或超声波）
· 视觉引导机器人手术
安全
· 生物识别（虹膜、指纹、人脸识别）
· 监视 - 检测某些可疑活动或行为
运输
· 自动驾驶汽车
· 安全，例如，驾驶员警惕性监控
工业自动化应用
· 工业检测（缺陷检测）
· 集会
· 条形码和包装标签读取
· 对象分类
· 文档理解（例如 OCR）
安装有用的包
对于使用 Python 的计算机视觉，您可以使用一个名为OpenCV（开源计算机视觉）的流行库。它是一个主要针对实时计算机视觉的编程函数库。它是用 C++ 编写的，其主要界面是用 C++ 编写的。您可以借助以下命令安装此软件包 -
pip install opencv_python-X.X-cp36-cp36m-winX.whl
这里的 X 代表您机器上安装的 Python 版本以及您拥有的 win32 或 64 位。
如果您使用的是anaconda环境，则使用以下命令安装 OpenCV -
conda install -c conda-forge opencv
读取、写入和显示图像
大多数 CV 应用程序需要将图像作为输入并生成图像作为输出。在本节中，您将学习如何借助 OpenCV 提供的函数来读写图像文件。
用于读取、显示、写入图像文件的 OpenCV 函数
OpenCV 为此提供了以下功能 -
· imread() 函数- 这是读取图像的函数。OpenCV imread() 支持各种图像格式，如 PNG、JPEG、JPG、TIFF 等。
· imshow() 函数- 这是在窗口中显示图像的函数。窗口自动适合图像大小。OpenCV imshow() 支持各种图像格式，如 PNG、JPEG、JPG、TIFF 等。
· imwrite() 函数- 这是写入图像的函数。OpenCV imwrite() 支持各种图像格式，如 PNG、JPEG、JPG、TIFF 等。
例子
此示例显示用于读取一种格式的图像的 Python 代码 - 在窗口中显示它并以其他格式写入相同的图像。考虑如下所示的步骤 -
如图所示导入 OpenCV 包 -
import cv2
现在，要读取特定图像，请使用 imread() 函数 -
image = cv2.imread('image_flower.jpg')
要显示图像，请使用imshow() 函数。您可以在其中查看图像的窗口的名称为image_flower。
cv2.imshow('image_flower',image)
cv2.destroyAllwindows()
现在，我们可以使用 imwrite() 函数将相同的图像写入其他格式，比如 .png -
cv2.imwrite('image_flower.png',image)
输出 True 表示图像已成功写入同一文件夹中的 .png 文件。
True
注意 - 函数 destroyallWindows() 只是销毁我们创建的所有窗口。
色彩空间转换
在 OpenCV 中，图像不是使用传统的 RGB 颜色存储的，而是以相反的顺序存储的，即 BGR 顺序。因此，读取图像时的默认颜色代码是 BGR。cvtColor () 颜色转换函数用于将图像从一种颜色代码转换为另一种颜色代码。
例子
考虑这个例子，将图像从 BGR 转换为灰度。
如图所示导入OpenCV 包 -
import cv2
现在，要读取特定图像，请使用 imread() 函数 -
image = cv2.imread('image_flower.jpg')
现在，如果我们使用 imshow() 函数查看此图像，那么我们可以看到此图像处于 BGR 状态。
cv2.imshow('BGR_Penguins',image)
现在，使用cvtColor() 函数将此图像转换为灰度图像。
image = cv2.cvtColor(image,cv2.COLOR_BGR2GRAY)
cv2.imshow('gray_penguins',image)
边缘检测
人类在看到粗略的草图后，可以很容易地识别出许多物体类型及其姿势。这就是边缘在人类生活以及计算机视觉应用中发挥重要作用的原因。OpenCV 提供了非常简单且有用的函数Canny() 来检测边缘。
例子
以下示例显示了对边缘的清晰识别。
如图所示导入 OpenCV 包 -
import cv2
import numpy as np
现在，要读取特定图像，请使用imread() 函数。
image = cv2.imread('Penguins.jpg')
现在，使用Canny () 函数检测已读取图像的边缘。
cv2.imwrite(‘edges_Penguins.jpg’,cv2.Canny(image,200,300))
现在，要显示带边缘的图像，请使用 imshow() 函数。
cv2.imshow(‘edges’, cv2.imread(‘‘edges_Penguins.jpg’))
这个 Python 程序将创建一个名为edges_penguins.jpg的带有边缘检测的图像。
人脸检测
人脸检测是计算机视觉的迷人应用之一，它使它更加逼真和未来。OpenCV 有一个内置的工具来执行人脸检测。我们将使用Haar级联分类器进行人脸检测。
Haar 级联数据
我们需要数据来使用 Haar 级联分类器。您可以在我们的 OpenCV 包中找到这些数据。安装 OpenCv 后，可以看到文件夹名称haarcascades。不同的应用程序会有 .xml 文件。现在，将它们全部复制以用于不同的用途，然后粘贴到当前项目下的新文件夹中。
例子
以下是使用 Haar Cascade 检测 Amitabh Bachan 面部的 Python 代码，如下图所示 -
如图所示导入OpenCV 包 -
import cv2
import numpy as np
现在，使用HaarCascadeClassifier检测人脸 -
face_detection=
cv2.CascadeClassifier('D:/ProgramData/cascadeclassifier/
haarcascade_frontalface_default.xml')
现在，要读取特定图像，请使用imread() 函数 -
img = cv2.imread('AB.jpg')
现在，将其转换为灰度，因为它会接受灰色图像 -
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
现在，使用face_detection.detectMultiScale执行实际的人脸检测
faces = face_detection.detectMultiScale(gray, 1.3, 5)
现在，在整个脸上画一个矩形 -
for (x,y,w,h) in faces:
img = cv2.rectangle(img,(x,y),(x+w, y+h),(255,0,0),3)
cv2.imwrite('Face_AB.jpg',img)
这个 Python 程序将创建一个名为Face_AB.jpg的图像，如图所示
眼睛检测
眼睛检测是计算机视觉的另一个引人入胜的应用，它使它更加逼真和具有未来感。OpenCV 有一个内置的工具来执行眼睛检测。我们将使用Haar 级联分类器进行眼睛检测。
例子
以下示例给出了使用 Haar Cascade 检测下图中给出的 Amitabh Bachan 面部的 Python 代码 -
如图所示导入 OpenCV 包 -
import cv2
import numpy as np
现在，使用HaarCascadeClassifier检测人脸 -
eye_cascade = cv2.CascadeClassifier('D:/ProgramData/cascadeclassifier/haarcascade_eye.xml')
现在，要读取特定图像，请使用imread() 函数
img = cv2.imread('AB_Eye.jpg')
现在，将其转换为灰度，因为它会接受灰色图像 -
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
现在借助eye_cascade.detectMultiScale，执行实际的人脸检测
eyes = eye_cascade.detectMultiScale(gray, 1.03, 5)
现在，在整个脸上画一个矩形 -
for (ex,ey,ew,eh) in eyes:
img = cv2.rectangle(img,(ex,ey),(ex+ew, ey+eh),(0,255,0),2)
cv2.imwrite('Eye_AB.jpg',img)
这个 Python 程序将创建一个名为Eye_AB.jpg的图像，并带有眼睛检测功能，如下所示 -
人工智能与 Python——深度学习
人工神经网络 (ANN) 是一种高效的计算系统，其中心主题借鉴了生物神经网络的类比。神经网络是机器学习的一种模型。在 20 世纪 80 年代中期和 90 年代初期，神经网络取得了许多重要的架构进步。在本章中，您将更多地了解深度学习，这是一种人工智能方法。
深度学习从十年的爆炸性计算增长中脱颖而出，成为该领域的有力竞争者。因此，深度学习是一种特殊的机器学习，其算法受到人脑结构和功能的启发。
机器学习与深度学习
深度学习是当今最强大的机器学习技术。它是如此强大，因为他们在学习如何解决问题的同时学习了表示问题的最佳方式。深度学习和机器学习的比较如下 -
数据依赖
第一个差异点是基于数据规模增加时 DL 和 ML 的性能。当数据很大时，深度学习算法表现非常好。
机器依赖
深度学习算法需要高端机器才能完美运行。另一方面，机器学习算法也可以在低端机器上运行。
特征提取
深度学习算法可以提取高级特征并尝试从中学习。另一方面，需要专家来识别机器学习提取的大部分特征。
执行时间
执行时间取决于算法中使用的众多参数。深度学习比机器学习算法有更多的参数。因此，DL 算法的执行时间，特别是训练时间，远远超过 ML 算法。但是 DL 算法的测试时间少于 ML 算法。
解决问题的方法
深度学习解决端到端的问题，而机器学习使用解决问题的传统方法，即将问题分解成多个部分。
卷积神经网络 (CNN)
卷积神经网络与普通神经网络一样，因为它们也是由具有可学习的权重和偏差的神经元组成。普通神经网络忽略输入数据的结构，所有数据在输入网络之前都被转换为一维数组。此过程适用于常规数据，但如果数据包含图像，则过程可能很繁琐。
CNN 轻松解决了这个问题。它在处理图像时考虑了图像的二维结构，这使他们能够提取特定于图像的属性。这样，CNN 的主要目标是从输入层的原始图像数据到输出层的正确类别。普通 NN 和 CNN 之间的唯一区别在于输入数据的处理方式和层的类型。
CNN 架构概述
在架构上，普通神经网络接收输入并通过一系列隐藏层对其进行转换。每一层都在神经元的帮助下连接到另一层。普通神经网络的主要缺点是它们不能很好地扩展到完整图像。
CNN 的架构将神经元排列成 3 个维度，称为宽度、高度和深度。当前层中的每个神经元都连接到前一层输出的一小块。它类似于在输入图像上叠加𝑵 × 𝑵 过滤器。 它使用M过滤器来确保获取所有细节。这些M滤波器是特征提取器，可以提取边缘、角等特征。
用于构建 CNN 的层
以下层用于构建 CNN -
· Input Layer - 它按原样获取原始图像数据。
· 卷积层- 该层是 CNN 的核心构建块，负责执行大部分计算。该层计算神经元与输入中各种补丁之间的卷积。
· Rectified Linear Unit Layer - 它将激活函数应用于前一层的输出。它为网络增加了非线性，因此它可以很好地泛化到任何类型的函数。
· 池化层- 池化帮助我们在网络中前进时只保留重要的部分。池化层在输入的每个深度切片上独立运行并在空间上调整它的大小。它使用 MAX 函数。
· 全连接层 / 输出层- 该层计算最后一层的输出分数。结果输出的大小为𝟏 × 𝟏 × 𝑳，其中 L 是训练数据集类的数量。
安装有用的 Python 包
您可以使用Keras，这是一种高级神经网络 API，用 Python 编写，能够在 TensorFlow、CNTK 或 Theno 之上运行。它与 Python 2.7-3.6 兼容。您可以从 keras.io了解更多信息。
使用以下命令安装 keras -
pip install keras
在conda环境中，您可以使用以下命令 -
conda install –c conda-forge keras
使用 ANN 构建线性回归器
在本节中，您将学习如何使用人工神经网络构建线性回归器。您可以使用KerasRegressor来实现这一点。在此示例中，我们使用波士顿房价数据集，其中包含 13 个数字表示波士顿的房产。此处显示了相同的 Python 代码 -
如图所示导入所有必需的包 -
import numpy
import pandas
from keras.models import Sequential
from keras.layers import Dense
from keras.wrappers.scikit_learn import KerasRegressor
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import KFold
现在，加载保存在本地目录中的数据集。
dataframe = pandas.read_csv("/Usrrs/admin/data.csv", delim_whitespace = True, header = None)
dataset = dataframe.values
现在，将数据分为输入和输出变量，即 X 和 Y -
X = dataset[:,0:13]
Y = dataset[:,13]
由于我们使用基线神经网络，定义模型 -
def baseline_model():
现在，按如下方式创建模型 -
model_regressor = Sequential()
model_regressor.add(Dense(13, input_dim = 13, kernel_initializer = 'normal',
activation = 'relu'))
model_regressor.add(Dense(1, kernel_initializer = 'normal'))
接下来，编译模型 -
model_regressor.compile(loss='mean_squared_error', optimizer='adam')
return model_regressor
现在，按如下方式修复随机种子以实现可重复性 -
seed = 7
numpy.random.seed(seed)
在 scikit-learn中用作回归估计器的 Keras 包装器对象称为KerasRegressor。在本节中，我们将使用标准化数据集评估该模型。
estimator = KerasRegressor(build_fn = baseline_model, nb_epoch = 100, batch_size = 5, verbose = 0)
kfold = KFold(n_splits = 10, random_state = seed)
baseline_result = cross_val_score(estimator, X, Y, cv = kfold)
print("Baseline: %.2f (%.2f) MSE" % (Baseline_result.mean(),Baseline_result.std()))
上面显示的代码的输出将是模型在未见数据问题上的性能估计。这将是均方误差，包括所有 10 次交叉验证评估的平均值和标准偏差。
图像分类器：深度学习的应用
卷积神经网络 (CNN) 解决图像分类问题，即输入图像属于哪一类。您可以使用 Keras 深度学习库。请注意，我们正在使用来自以下链接kaggle的猫狗图像的训练和测试数据集。
如图所示导入重要的 keras 库和包 -
以下名为 sequential 的包会将神经网络初始化为顺序网络。
from keras.models import Sequential
以下称为Conv2D 的包用于执行卷积运算，这是 CNN 的第一步。
from keras.layers import Conv2D
以下名为MaxPoling2D的包用于执行池化操作，即 CNN 的第二步。
from keras.layers import MaxPooling2D
以下名为Flatten 的包是将所有生成的二维数组转换为单个长连续线性向量的过程。
from keras.layers import Flatten
下面这个名为Dense的包是用来进行神经网络的全连接的，CNN的第四步。
from keras.layers import Dense
现在，创建顺序类的对象。
S_classifier = Sequential()
现在，下一步是对卷积部分进行编码。
S_classifier.add(Conv2D(32, (3, 3), input_shape = (64, 64, 3), activation = 'relu'))
这里的relu是整流函数。
现在，CNN 的下一步是在卷积部分之后对生成的特征图进行池化操作。
S-classifier.add(MaxPooling2D(pool_size = (2, 2)))
现在，使用奉承将所有合并图像转换为连续向量 -
S_classifier.add(Flatten())
接下来，创建一个全连接层。
S_classifier.add(Dense(units = 128, activation = 'relu'))
这里，128 是隐藏单元的数量。通常的做法是将隐藏单元的数量定义为 2 的幂。
现在，按如下方式初始化输出层 -
S_classifier.add(Dense(units = 1, activation = 'sigmoid'))
现在，编译 CNN，我们已经构建了 -
S_classifier.compile(optimizer = 'adam', loss = 'binary_crossentropy', metrics = ['accuracy'])
这里optimizer参数是选择随机梯度下降算法，loss参数是选择损失函数，metrics参数是选择性能指标。
现在，执行图像增强，然后将图像拟合到神经网络 -
train_datagen = ImageDataGenerator(rescale = 1./255,shear_range = 0.2,
zoom_range = 0.2,
horizontal_flip = True)
test_datagen = ImageDataGenerator(rescale = 1./255)
training_set =
train_datagen.flow_from_directory(”/Users/admin/training_set”,target_size =
(64, 64),batch_size = 32,class_mode = 'binary')
test_set =
test_datagen.flow_from_directory('test_set',target_size =
(64, 64),batch_size = 32,class_mode = 'binary')
现在，将数据拟合到我们创建的模型中 -
classifier.fit_generator(training_set,steps_per_epoch = 8000,epochs =
25,validation_data = test_set,validation_steps = 2000)
这里 steps_per_epoch 有训练图像的数量。
现在模型已经过训练，我们可以使用它进行预测，如下所示 -
from keras.preprocessing import image
test_image = image.load_img('dataset/single_prediction/cat_or_dog_1.jpg',
target_size = (64, 64))
test_image = image.img_to_array(test_image)
test_image = np.expand_dims(test_image, axis = 0)
result = classifier.predict(test_image)
training_set.class_indices
if result[0][0] == 1:
prediction = 'dog'
else:
prediction = 'cat'
