Giải thuật cắt tỉa Alpha – Beta

Giải thuật cắt tỉa Alpha – Beta đây là một trong những
phương pháp tối ưu giúp cho thuật toán minimax có thể
tìm ra phương pháp nhanh hơn vì phương pháp này giúp
loại bỏ một vài nhánh trong quá trình tìm kiếm, là giới
hạn lại pham vi tìm kiếm, giúp cho mô hình hay thuật
toán hoạt động một cách nhanh hơn và tối ưu hơn.
Thuật toán sẽ hoạt động hiệu quả hơn nếu những bước tìm
kiếm đầu tiên là những nước đi tốt nhất .

Mã giả:
function minimax(node, depth, alpha, beta,
maximizingPlayer) is
if depth ==0 or node is a terminal node then
return -evaluateBoard(game.board());

var newGameMoves = game.moves();

if MaximizingPlayer then
var bestMove= -9999
for (var i = 0; i < newGameMoves.length; i++)
game.moves(newGameMoves[i])
 bestMove = Math.max(bestMove,
minimax(depth - 1, game, alpha, beta, !
isMaximisingPlayer))
game.undo()
alpha = Math.max(alpha, bestMove)
if beta<=alpha then
return bestMove;
return bestMove
else
var bestMove = 9999
for (var i = 0; i < newGameMoves.length; i++)
game.moves(newGameMoves[i])
bestMove = Math.min(bestMove, minimax(depth - 1,
game, alpha, beta, !isMaximisingPlayer))
game.undo()
beta = Math.min(beta, bestMove)
if beta<=alpha
return bestMove;
return minEva

Code:
function minimax(depth, game, alpha, beta,
isMaximisingPlayer) {
positionCount++;
if (depth === 0) {
return -evaluateBoard(game.board());
}

var newGameMoves = game.moves();

if (isMaximisingPlayer) {
var bestMove = -9999;
for (var i = 0; i < newGameMoves.length; i++) {
game.moves(newGameMoves[i]);
bestMove = Math.max(bestMove, minimax(depth - 1,
game, alpha, beta, !isMaximisingPlayer));
game.undo();
alpha = Math.max(alpha, bestMove);
if (beta <= alpha) {
return bestMove;
 }
}
return bestMove;
} else {
var bestMove = 9999;
for (var i = 0; i < newGameMoves.length; i++) {
game.moves(newGameMoves[i]);
bestMove = Math.min(bestMove, minimax(depth - 1,
game, alpha, beta, !isMaximisingPlayer));
game.undo();
beta = Math.min(beta, bestMove);
if (beta <= alpha) {
return bestMove;
}
}
return bestMove;
}
}
Chú thích code:
 bestMove = Math.max(bestMove, minimax(depth - 1,
game, alpha, beta, !isMaximisingPlayer)); // Hàm xét
max
bestMove = Math.min(bestMove, minimax(depth - 1,
game, alpha, beta, !isMaximisingPlayer)); // Hàm xét min
alpha = Math.max(alpha, bestMove); // Hàm xét giá trị
alpha
beta = Math.min(beta, bestMove); // Hàm xét giá trị beta
if (beta <= alpha) {
return bestMove;
} // hàm ngắt xét cây

Giải thích thuật toán:

 Ảnh minh họa Alpha-Beta
Với mô hình trên đây, ta sẽ xét từ trái qua phải bắt đầu từ
nút gốc và nút con bên trái sẽ được ưu tiên duyệt trước.

function minimax(node, depth, alpha, beta,

maximizingPlayer) dùng hàm này để xét độ sâu của
miniax.
Xét duyệt từ trên gốc xuống sâu (vì ban đầu chưa hề tồn
tại giá trị alpha hay beta của các nút do đó các giá trị lúc
này đều là null).
Khi chạm đến cuối của hàm minimax thì lúc này ta duyệt
là E có giá trị 2 ( alpha >= 2), khi đó ở trên ta chưa có giá
trị Beta để ta có thể so sánh vì thế ta tiếp tục duyệt con
tiếp theo E thì lúc này ta sẽ ta thấy có giá trị là 3 và đem
nó so sánh với 2 ta được là alpha=3 (Max).
Lưu ý là luôn luôn duyệt từ trái sang phải và phải lần lượt
từng nhánh một, sau đó sang nhánh tiếp theo cùng gốc.
Vậy nên tiếp theo chúng ta sẽ đưa giá trị alpha này lên nút
B (Min) và nút B – beta <= 3, sau đó nút F sẽ được duyệt,
và ta phải tìm alpha của F.
Khi duyệt con đầu tiên mang giá trị 5 vậy alpha của F –
alpha >= 5.
Do đó tại nút E α = 5 và β = 3, trong đó α> = β, vì vậy kế
thừa bên phải của E sẽ bị lược bỏ, và thuật toán sẽ không
đi qua nó, và giá trị tại nút E sẽ là 5.
Tiếp theo, thuật toán lại chiếu ngược cây, từ nút B đến nút
A. Tại nút A, giá trị của alpha sẽ được thay đổi giá trị lớn
nhất có sẵn là 3 như max (-∞, 3) = 3 và β = + ∞, hai giá trị
này bây giờ được chuyển đến người kế nhiệm bên phải
của A là Nút C.
Tại nút C, α = 3 và β = + ∞, và các giá trị tương tự sẽ
được chuyển cho nút F.
Tại nút F, một lần nữa giá trị của α sẽ được so sánh với
nút con bên trái là 0 và max (3,0) = 3, sau đó so sánh với
nút con bên phải là 1 và max (3,1) = 3 vẫn còn α vẫn là 3,
nhưng giá trị nút của F sẽ trở thành 1.
 Nút F trả về giá trị nút 1 cho nút C, tại C α = 3 và β = +
∞, ở đây giá trị beta sẽ được thay đổi, nó sẽ so sánh với 1
nên min (∞, 1) = 1. Bây giờ tại C, α = 3 và β = 1, và một
lần nữa nó thỏa mãn điều kiện α> = β, vì vậy con tiếp theo
của C là G sẽ bị lược bớt, và thuật toán sẽ không tính toàn
bộ cây con G.
Lúc này C bây giờ sẽ trả về giá trị từ 1 đến A ở đây giá trị
tốt nhất cho A là max (3, 1) = 3