Initial commit

This commit is contained in:
Pullarla 2021-10-19 10:50:20 +08:00
parent 6cdb771f66
commit 28ffcf80a0
4 changed files with 710 additions and 2 deletions

View File

@ -1,3 +1,89 @@
# AT_chess
# 基于α-β剪枝算法实现的AI五子棋游戏
基于α-β剪枝算法实现的AI五子棋游戏
# 一、对抗问题
对抗问题:顾名思义,博弈双方是带有对抗性质的。博弈的任何一方都希望局面尽量对自己有利,同时局面也应该尽量令对方不利。通常这一类问题可以通过 Minimax 算法解决。
Minimax 算法又名极小化极大算法是一种找出失败的最大可能性中的最小值的算法。Minimax 算法常用于棋类等由两方较量的游戏和程序,这类程序由两个游戏者轮流,每次执行一个步骤。为了执行 Minimax 算法,我们可以通过穷举的方式,枚举所有的状态空间,从而使得我们可以在游戏刚一开始,就预测到输赢。但是,在实际情况下,游戏的状态空间都是异常庞大的。很显然,我们不能将以穷举方式实现的 Minimax 算法用于实际应用。
# 二、α-β减枝
通过分析可以发现,在利用穷举方法执行 Minimax 算法中有许多的无效搜索,也就是说,许多明显较劣的状态分支我们也进行搜索了。我们在进行极大值搜索的时候,我们仅仅关心,下面最大的状态,对于任何小于目前值的分支也都是完全没有必要进行进一步检查的。(α减枝)
![](http://www.write-bug.com/myres/static/uploads/2021/10/19/008122f5dceee247a34ccdf40fd178be.writebug)
通过上图,我们可以发现,我们可以减去大量无用的状态检查,从而降低我们的运算量。
同时,我们在进行极小值搜索的时候,我们仅仅关心,下面最小的状态,对于任何大于目前值的分支都是完全没有必要进行进一步检查的。(β 减枝)
![](http://www.write-bug.com/myres/static/uploads/2021/10/19/1660b5600455ef92fadef661894a8f76.writebug)
通过上图,我们可以发现,我们可以减去大量无用的状态检查,从而降低我们的运算量。
将上述所提到的 α 减枝与 β 减枝进行综合就可以得到 α-β 减枝。对于对抗搜索而言,我们需要精心设计其估值函数,不然我们的 α-β 减枝将毫无用武之地。
# 三、五子棋问题
五子棋:是一种两人对弈的纯策略型棋类游戏,通常双方分别使用黑白两色的棋子,下在棋盘直线与横线的交叉点上,先形成 5 子连线者获胜。
![](http://www.write-bug.com/myres/static/uploads/2021/10/19/8bb59de479478d8ac23de93f14978870.writebug)
这里,我们采用了极大极小博弈树(MGT),来实现 AI。这里用一张井字棋的搜索示意图来说明。
![](http://www.write-bug.com/myres/static/uploads/2021/10/19/5adfb1724d5c6b047398c100cb6f74b6.writebug)
上图很清晰的展示了对局可能出现的所有情况(已经去除了等价的情况),如果让这个图延展下去,我们就相当于穷举了所有的下法,如果我们能在知道所有下法的情况下,对这些下法加以判断,我们的 AI自然就可以选择具有最高获胜可能的位置来下棋。极大极小博弈树就是一种选择方法由于五子棋以及大多数博弈类游戏是无法穷举出所有可能的步骤的状态会随着博弈树的扩展而呈指数级增长所以通常我们只会扩展有限的层数而 AI 的智能高低通常就会取决于能够扩展的层数层数越高AI 了解的信息就越多,就越能做出有利于它的判断。
为了让计算机选择那些获胜可能性高的步骤走,我们就需要一个对局面进行打分的算法,越有利,算法给出的分数越高。在得到这个算法过后,计算机就可以进行选择了,在极大极小博弈树上的选择规则是这样的:
- AI 会选择子树中具有最高估值叶子节点的路径
- USER 会选择子树中具有最小估值叶子节点的路径
这样的原则很容易理解,作为玩家,我所选择的子一定要使自己的利益最大化,而相应的在考虑对手的时候,也不要低估他,一定要假设他会走对他自己最有利,也就是对我最不利的那一步。
接下来,我们实现关键的局面评分步骤:直接分析整个棋面是一件很复杂的事情,为了让其具备可分析性,我们可以将其进行分解,分解成易于我们理解和实现的子问题。
对于一个二维的期面,五子棋不同于围棋,五子棋的胜负只取决于一条线上的棋子,所以根据五子棋的这一特征,我们就来考虑将二维的棋面转换为一维的,下面是一种简单的思考方式,对于整个棋盘,我们只需要考虑四个方向即可,所以我们就按照四个方向来将棋盘转换为 15 * 6 个长度不超过 15 的一维向量(分解斜向的时候,需要分为上下两个半区),参考下图:
![](http://www.write-bug.com/myres/static/uploads/2021/10/19/578750182a4a7c57c1e6786721989f44.writebug)
我们的目的是为了为其评分,那么我们就还需要评估每个线状态,将每个线状态的评分进行汇总,当做我们的棋面评分:
![](http://www.write-bug.com/myres/static/uploads/2021/10/19/d0f5d8c6e980af7da80e08b4f510936e.writebug)
接下来我们所要做的就是评价每一条线状态,根据五子棋的规则,我们可以很容易穷举出各种可能出现的基本棋型,我们首先为这些基本棋型进行识别和评价,并且统计每个线状态中出现了多少种下面所述的棋型,并据此得出评价值,得到如下图所示的静态估值表:
![](http://www.write-bug.com/myres/static/uploads/2021/10/19/cf8af1d7601101cceea19dd707f68eb8.writebug)
根据这个表以及我们之前所谈到的规则我们就可以得到一个可以运行的AI了。
# 四、进一步的优化
注意到如果我们搜索到第四层总共需要搜索224 + 224 * 223 + 224 * 223 * 222 + 224 * 223 * 222 * 221 = 2 461 884 544 个状态节点,搜索如此多的状态节点的开销是十分可观的,因此,我们提高效率的方式就锁定到了:如何减少需要搜索的状态节点。
我们可以采取以下方法来减少需要搜索的状态节点:
- 我们可以利用经典的α-β剪枝算法对博弈树剪枝
- 我们可以每次搜索仅搜索落子点周围 2\*2 格范围内存在棋子的位置,这样可以避免搜索一些明显无用的节点,而且可以大幅度提升整体搜索速度
- 避免对必胜/负局面搜索,当搜索过程中出现了必胜/负局面的时候直接返回不再搜索,因为此时继续搜索是没有必要的,直接返回当前棋局的估价值即可
- 加入随机化AI的下棋方式普通的AI算法对于给定的玩家下棋方式会给出固定的回应这就导致玩家获胜一次之后只要此后每次都按此方式下棋都能够获胜。为了避免这种情况可以在 AI选择下子位置的时候在估值相差不多的几个位置中随机挑选一个进行放置以此增加 AI的灵活性
规划搜索顺序,有很多有价值的下子点存在于更靠近棋盘中央的地方,如果从棋盘中央向外搜索的话,则能够提高α-β剪枝的效率,让尽可能多的分支被排除
# 五、实验成果
![](http://www.write-bug.com/myres/static/uploads/2021/10/19/f35838e45157b3624edd0764123fd6dd.writebug)
![](http://www.write-bug.com/myres/static/uploads/2021/10/19/cf64dfc26f617ddbb6e734942f8b33dd.writebug)
# 六、实验总结
通过本次实验,加强了组员之间的沟通协调能力,同时也提高了我们对αβ减枝算法的了解。我们更了解了五子棋相关的游戏规则以及一些技巧,拓宽了我们的知识面,有助于我们在未来的生活中更好的与人交流。
同时,经过此次实验,我们深入了解了棋类人工智能算法,进一步的提升了我们的专业水平,有助于我们在未来的就业与科研岗位上走的更远。
虽然α-β减枝实现起来非常容易但是五子棋的局势估计却十分的有挑战性其局势估计的准确与否直接影响了程序的运行结果是否令人满意AI是否能够展现出足够的智能。

17
src/.gitattributes vendored Normal file
View File

@ -0,0 +1,17 @@
# Auto detect text files and perform LF normalization
* text=auto
# Custom for Visual Studio
*.cs diff=csharp
# Standard to msysgit
*.doc diff=astextplain
*.DOC diff=astextplain
*.docx diff=astextplain
*.DOCX diff=astextplain
*.dot diff=astextplain
*.DOT diff=astextplain
*.pdf diff=astextplain
*.PDF diff=astextplain
*.rtf diff=astextplain
*.RTF diff=astextplain

605
src/五子棋代码.cpp Normal file
View File

@ -0,0 +1,605 @@
#include "opencv2/imgproc/imgproc.hpp"
#include "opencv2/imgcodecs.hpp"
#include "opencv2/videoio/videoio.hpp"
#include "opencv2/highgui/highgui.hpp"
#include <iostream>
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdio>
#include <cstdlib>
#include <iomanip>
using namespace std;
using namespace cv;
//sro 菜神 Orz
cv::Mat chessboard, whiteChess, blackChess, tmp, BGS;
int is_red(Vec3b X) {
// cout << (int)X[1] << ' ' << (int)X[2] << ' ' << (int)X[3] << endl;
return X[0] < 200 && X[1] < 200 && X[2] > 230;
}
cv::Mat BG;
void imageCopyToBG(cv::Mat chess, int x, int y) {
x *= 35;
y *= 35;
int rows = chess.rows;
int cols = chess.cols;
for (int i = 0; i < rows; ++i) {
for (int j = 0; j < cols; ++j) {
if (!is_red(chess.at<Vec3b>(i, j))) {
BG.at<Vec3b>(x + i + 8, y + j + 8) = chess.at<Vec3b>(i, j);
}
}
}
}
/*
*/
class CONFIG {
public:
static const int BOARD_SIZE = 15;
static const int EMPTY = 0;
static const int USER_1 = 1;
static const int USER_2 = 2;
static const int AI_EMPTY = 0; // 无子
static const int AI_MY = 1; // 待评价子
static const int AI_OP = 2; // 对方子或不能下子
static const int MAX_NODE = 2;
static const int MIN_NODE = 1;
static const int INF = 106666666;
static const int ERROR_INDEX = -1;
//估价值
static const int AI_ZERO = 0;
static const int AI_ONE = 10;
static const int AI_ONE_S = 1;
static const int AI_TWO = 100;
static const int AI_TWO_S = 10;
static const int AI_THREE = 1000;
static const int AI_THREE_S = 100;
static const int AI_FOUR = 10000;
static const int AI_FOUR_S = 1000;
static const int AI_FIVE = 100000;
};
/*
*/
class Grid :CONFIG {
public:
int type; //类型
Grid() {
type = EMPTY;
}
Grid(int t) {
type = t;
}
void grid(int t = EMPTY) {
type = t;
}
int isEmpty() {
return type == EMPTY ? true : false;
}
};
/*
*/
class ChessBoard :CONFIG {
public:
Grid chessBoard[BOARD_SIZE][BOARD_SIZE];
ChessBoard() {
for (int i = 0; i < BOARD_SIZE; ++i)
for (int j = 0; j < BOARD_SIZE; ++j)
chessBoard[i][j].grid();
}
ChessBoard(const ChessBoard &othr) {
for (int i = 0; i < BOARD_SIZE; ++i)
for (int j = 0; j < BOARD_SIZE; ++j)
chessBoard[i][j].grid(othr.chessBoard[i][j].type);
}
/*
*/
bool placePiece(int x, int y, int type) {
if (chessBoard[x][y].isEmpty()) {
chessBoard[x][y].type = type;
return true;
}
return false;
}
};
/*
AI
*/
class Game :CONFIG {
public:
ChessBoard curState; // 当前棋盘
bool isStart; // 是否进行中
int curUser; // 当前行棋人
int MAX_DEPTH; // 最大搜索层数
/*
*/
void startGame(int nd = 2) {
MAX_DEPTH = nd;
isStart = true;
curUser = USER_1;
}
/*
*/
void changeUser() {
curUser = curUser == USER_1 ? USER_2 : USER_1;
}
/*
type
A:
type:
A是待判断棋子
*/
int getPieceType(int A, int type) {
return A == type ? AI_MY : (A == EMPTY ? AI_EMPTY : AI_OP);
}
int getPieceType(const ChessBoard &board, int x, int y, int type) {
if (x < 0 || y < 0 || x >= BOARD_SIZE || y >= BOARD_SIZE)// 超出边界按对方棋子算
return AI_OP;
else
return getPieceType(board.chessBoard[x][y].type, type);
}
/*
*/
bool placePiece(int x, int y) {
if (curState.placePiece(x, y, curUser)) {
// 检察行棋人是否胜利
if (isWin(x, y)) {
isStart = false; // 游戏结束
// return true;
}
changeUser(); // 转换游戏角色
return true;
}
return false;
}
bool isWin(int x, int y) {
if (evaluatePiece(curState, x, y, curUser) >= AI_FIVE)
return true;
return false;
}
/*
center作为评估位置进行评价一个方向的棋子
*/
int evaluateLine(int line[], bool ALL) {
int value = 0; // 估值
int cnt = 0; // 连子数
int blk = 0; // 封闭数
for (int i = 0; i < BOARD_SIZE; ++i) {
if (line[i] == AI_MY) { // 找到第一个己方的棋子
// 还原计数
cnt = 1;
blk = 0;
// 看左侧是否封闭
if (line[i - 1] == AI_OP)
++blk;
// 计算连子数
for (i = i + 1; i < BOARD_SIZE && line[i] == AI_MY; ++i, ++cnt);
// 看右侧是否封闭
if (line[i] == AI_OP)
++blk;
// 计算评估值
value += getValue(cnt, blk);
}
}
return value;
}
/*
center作为评估位置进行评价一个方向的棋子4
*/
int evaluateLine(int line[]) {
int cnt = 1; // 连子数
int blk = 0; // 封闭数
// 向左右扫
for (int i = 3; i >= 0; --i) {
if (line[i] == AI_MY) ++cnt;
else if (line[i] == AI_OP) {
++blk;
break;
}
else
break;
}
for (int i = 5; i < 9; ++i) {
if (line[i] == AI_MY) ++cnt;
else if (line[i] == AI_OP) {
++blk;
break;
}
else
break;
}
return getValue(cnt, blk);
}
/*
*/
int getValue(int cnt, int blk) {
if (blk == 0) {// 活棋
switch (cnt) {
case 1:
return AI_ONE;
case 2:
return AI_TWO;
case 3:
return AI_THREE;
case 4:
return AI_FOUR;
default:
return AI_FIVE;
}
}
else if (blk == 1) {// 单向封死
switch (cnt) {
case 1:
return AI_ONE_S;
case 2:
return AI_TWO_S;
case 3:
return AI_THREE_S;
case 4:
return AI_FOUR_S;
default:
return AI_FIVE;
}
}
else {// 双向堵死
if (cnt >= 5)
return AI_FIVE;
else
return AI_ZERO;
}
}
/*
*/
int evaluatePiece(ChessBoard state, int x, int y, int type) {
int value = 0; // 估价值
int line[17]; //线状态
bool flagX[8];// 横向边界标志
flagX[0] = x - 4 < 0;
flagX[1] = x - 3 < 0;
flagX[2] = x - 2 < 0;
flagX[3] = x - 1 < 0;
flagX[4] = x + 1 > 14;
flagX[5] = x + 2 > 14;
flagX[6] = x + 3 > 14;
flagX[7] = x + 4 > 14;
bool flagY[8];// 纵向边界标志
flagY[0] = y - 4 < 0;
flagY[1] = y - 3 < 0;
flagY[2] = y - 2 < 0;
flagY[3] = y - 1 < 0;
flagY[4] = y + 1 > 14;
flagY[5] = y + 2 > 14;
flagY[6] = y + 3 > 14;
flagY[7] = y + 4 > 14;
line[4] = AI_MY; // 中心棋子
// 横
line[0] = flagX[0] ? AI_OP : (getPieceType(state.chessBoard[x - 4][y].type, type));
line[1] = flagX[1] ? AI_OP : (getPieceType(state.chessBoard[x - 3][y].type, type));
line[2] = flagX[2] ? AI_OP : (getPieceType(state.chessBoard[x - 2][y].type, type));
line[3] = flagX[3] ? AI_OP : (getPieceType(state.chessBoard[x - 1][y].type, type));
line[5] = flagX[4] ? AI_OP : (getPieceType(state.chessBoard[x + 1][y].type, type));
line[6] = flagX[5] ? AI_OP : (getPieceType(state.chessBoard[x + 2][y].type, type));
line[7] = flagX[6] ? AI_OP : (getPieceType(state.chessBoard[x + 3][y].type, type));
line[8] = flagX[7] ? AI_OP : (getPieceType(state.chessBoard[x + 4][y].type, type));
value += evaluateLine(line);
// 纵
line[0] = flagY[0] ? AI_OP : getPieceType(state.chessBoard[x][y - 4].type, type);
line[1] = flagY[1] ? AI_OP : getPieceType(state.chessBoard[x][y - 3].type, type);
line[2] = flagY[2] ? AI_OP : getPieceType(state.chessBoard[x][y - 2].type, type);
line[3] = flagY[3] ? AI_OP : getPieceType(state.chessBoard[x][y - 1].type, type);
line[5] = flagY[4] ? AI_OP : getPieceType(state.chessBoard[x][y + 1].type, type);
line[6] = flagY[5] ? AI_OP : getPieceType(state.chessBoard[x][y + 2].type, type);
line[7] = flagY[6] ? AI_OP : getPieceType(state.chessBoard[x][y + 3].type, type);
line[8] = flagY[7] ? AI_OP : getPieceType(state.chessBoard[x][y + 4].type, type);
value += evaluateLine(line);
// 左上-右下
line[0] = flagX[0] || flagY[0] ? AI_OP : getPieceType(state.chessBoard[x - 4][y - 4].type, type);
line[1] = flagX[1] || flagY[1] ? AI_OP : getPieceType(state.chessBoard[x - 3][y - 3].type, type);
line[2] = flagX[2] || flagY[2] ? AI_OP : getPieceType(state.chessBoard[x - 2][y - 2].type, type);
line[3] = flagX[3] || flagY[3] ? AI_OP : getPieceType(state.chessBoard[x - 1][y - 1].type, type);
line[5] = flagX[4] || flagY[4] ? AI_OP : getPieceType(state.chessBoard[x + 1][y + 1].type, type);
line[6] = flagX[5] || flagY[5] ? AI_OP : getPieceType(state.chessBoard[x + 2][y + 2].type, type);
line[7] = flagX[6] || flagY[6] ? AI_OP : getPieceType(state.chessBoard[x + 3][y + 3].type, type);
line[8] = flagX[7] || flagY[7] ? AI_OP : getPieceType(state.chessBoard[x + 4][y + 4].type, type);
value += evaluateLine(line);
// 右上-左下
line[0] = flagX[7] || flagY[0] ? AI_OP : getPieceType(state.chessBoard[x + 4][y - 4].type, type);
line[1] = flagX[6] || flagY[1] ? AI_OP : getPieceType(state.chessBoard[x + 3][y - 3].type, type);
line[2] = flagX[5] || flagY[2] ? AI_OP : getPieceType(state.chessBoard[x + 2][y - 2].type, type);
line[3] = flagX[4] || flagY[3] ? AI_OP : getPieceType(state.chessBoard[x + 1][y - 1].type, type);
line[5] = flagX[3] || flagY[4] ? AI_OP : getPieceType(state.chessBoard[x - 1][y + 1].type, type);
line[6] = flagX[2] || flagY[5] ? AI_OP : getPieceType(state.chessBoard[x - 2][y + 2].type, type);
line[7] = flagX[1] || flagY[6] ? AI_OP : getPieceType(state.chessBoard[x - 3][y + 3].type, type);
line[8] = flagX[0] || flagY[7] ? AI_OP : getPieceType(state.chessBoard[x - 4][y + 4].type, type);
value += evaluateLine(line);
return value;
}
/*
*/
int evaluateState(ChessBoard state, int type) {
int value = 0;
// 分解成线状态
int line[6][17];
int lineP;
for (int p = 0; p < 6; ++p)
line[p][0] = line[p][16] = AI_OP;
// 从四个方向产生
for (int i = 0; i < BOARD_SIZE; ++i) {
// 产生线状态
lineP = 1;
for (int j = 0; j < BOARD_SIZE; ++j) {
line[0][lineP] = getPieceType(state, i, j, type); /* | */
line[1][lineP] = getPieceType(state, j, i, type); /* - */
line[2][lineP] = getPieceType(state, i + j, j, type); /* \ */
line[3][lineP] = getPieceType(state, i - j, j, type); /* / */
line[4][lineP] = getPieceType(state, j, i + j, type); /* \ */
line[5][lineP] = getPieceType(state, BOARD_SIZE - j - 1, i + j, type); /* / */
++lineP;
}
// 估计
int special = i == 0 ? 4 : 6;
for (int p = 0; p < special; ++p) {
value += evaluateLine(line[p], true);
}
}
return value;
}
/*
x, y位置周围1格内有棋子则搜索
*/
bool canSearch(ChessBoard state, int x, int y) {
int tmpx = x - 1;
int tmpy = y - 1;
for (int i = 0; tmpx < BOARD_SIZE && i < 3; ++tmpx, ++i) {
int ty = tmpy;
for (int j = 0; ty < BOARD_SIZE && j < 3; ++ty, ++j) {
if (tmpx >= 0 && ty >= 0 && state.chessBoard[tmpx][ty].type != EMPTY)
return true;
else
continue;
}
}
return false;
}
/*
*/
int nextType(int type) {
return type == MAX_NODE ? MIN_NODE : MAX_NODE;
}
/*
state
type MAX MIN
depth
alpha alpha值
beta beta值
*/
int minMax(ChessBoard state, int x, int y, int type, int depth, int alpha, int beta) {
ChessBoard newState(state);
newState.placePiece(x, y, nextType(type));
int weight = 0;
int max = -INF; // 下层权值上界
int min = INF; // 下层权值下界