四子棋人工智能

人工智能作业

姓名：guojl

学号：2620139012 指导老师：刘峡壁

1. 要求

每一道编程题需提交四份文件：（1）可执行程序；（2）源代码；（3）程序设计说明；（4）程序使用说明。

注：以上文件请打包成一个压缩文件，以“学号_姓名_大作业名称”方式命名后提交。在文件中请留下你的个人联系方式，以便在出现文件不能解压、不能打开、程序不能编译运行等各种情况时与你联系

Implement a computer game program which must satisfy the following requirements：

1. Use alpha-beta algorithm to search the solutions;

2. The allowed maximum depth of the game tree is 8;

3. Use neural network to evaluate the states of leaves in the game tree；

4. Use some machine learning method to train this neural network in the process of

competing against itself or others.

Tic Tac Toe on a 4x4 Board（4x4一字棋）

Playing Rules:

1) X always goes first.

2) The Players alternate placing Xs and Os on the board until either (a) one player has

four in a row horizontally, vertically or diagonally; or (b) all 16 squares are filled.

3) If a player is able to draw four Xs or four Os in a row, that player wins.

4) If all 16 squares are filled and neither player has four in a row, the game is a draw.

1，给电脑安装JDK1.6以上版本，推荐JDK1.7

2，请将BP_net_weight.txt文件拷贝到我的电脑的C盘根目录下

3，点击运行Tic-Toc-Too.jar或者Tic-Toc-Too-*.exe

其中

包结构如下：

1，BpNeuralNetworks代码如下：package ncse.bpNeuralNetworks;

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.InputStreamReader;

import java.io.OutputStreamWriter;

/**

* 神经网络评估

* @author guojl

* @version 20141124

*/

public class BpNeuralNetworks {

private static double ETA = 0.7;

private static int N = 4; // 输入层节点数

private static int SIZE = N * N;

private static int MAXVAL = Short.MAX_VALUE;

private static int MINVAL = Short.MIN_VALUE;

private double input_layer[]; // 输入层

private double competition_layer[]; // 隐藏层

private double output_layer; // 输出层（激活函数作用之前）

private double y_i; // 神经网络输出（经过激活函数作用）

private double w_ji[]; // 隐藏层到输出层权重，隐藏层N个节点到输出层1个节点

private double w_kj[][]; // 输入层到隐藏层权重，输入层N个节点到隐藏层N 个节点

private double y_j[]; // 隐藏层经过激活函数作用之后，即出输出的输入

// private String filepath=System.getProperty("user.dir")+"//src//ncse//res//BP_net_weight.txt" ;

// private String filepath=getClass().getResource("/")+"//ncse//res//BP_net_weight.txt" ;

private String filepath="C://BP_net_weight.txt" ;

// 神经网络初始化

public BpNeuralNetworks() {

input_layer = new double[SIZE];

competition_layer = new double[SIZE];

w_ji = new double[SIZE];

w_kj = new double[SIZE][SIZE];

y_j = new double[SIZE];

init_net();

}

// 初始化神经网络的输入层隐藏层输出层

private void init_net() {

for (int i = 0; i < SIZE; i++) {

input_layer[i] = 0.0;

competition_layer[i] = 0.0;

}

output_layer = 0.0;

}

// 初始化权重

public void init_weight() {

for (int i = 0; i < SIZE; i++) {

w_ji[i] = Math.random();

}

for (int i = 0; i < SIZE; i++) {

for (int j = 0; j < SIZE; j++) {

w_kj[i][j] = Math.random();

}

}

}

// 激活函数。采用双曲正切函数。

// 输入：整合函数值（整合函数为加权求和）。

// 返回值：激活函数值。

private double logistic_s(double theta) {

return (1.0 - Math.exp(-theta)) / (1.0 + Math.exp(theta));

}

// BP神经网络应用函数。输入棋盘，立即得到其倒推值。

// 输入：当前棋盘状态。

// 返回值：神经网络输出值（需要乘以MAX才等于倒推值）。public double BP_net_value(int[] chess_board) {

init_net();

// 输入层赋值，当前棋盘状态

for (int i = 0; i < SIZE; i++) {

input_layer[i] = (double) chess_board[i];

}

// 计算隐藏层

for (int j = 0; j < SIZE; j++) {

for (int k = 0; k < SIZE; k++) {

competition_layer[j] += w_kj[k][j] * input_layer[k];

}

}

// 计算输出层

for (int j = 0; j < SIZE; j++) {

y_j[j] = logistic_s(competition_layer[j]);

output_layer += w_ji[j] * y_j[j];

}

y_i = logistic_s(output_layer);

return y_i;

}

// 调整权值函数。进行不超过最大迭代次数的正向/反向传播过程，不断调整权值。如果误差小于允许值则结束。

// 输入：一组学习样本（代表棋盘的16维向量以及对应倒推值）。

// 返回值：void

public void adjust_BP_net_weight(int[] chess_board, int backed_up_value) {

int iteration_times = 1000000;

int temp_iteration_times = 0;

while (true) {

y_i = BP_net_value(chess_board);

// 如果达到允许的最小误差或最大迭代次数，退出并结束本次学习

if (Math.abs(y_i - (double) backed_up_value / (double) MAXVAL) < 0.000001

|| temp_iteration_times >= iteration_times) {

break;

}

// 开始反向传播误差，调整权重

for (int j = 0; j < SIZE; j++) {

w_ji[j] = w_ji[j] - ETA * y_j[j] * (1 - y_i * y_i)

* (y_i - (double) backed_up_value / (double) MAXVAL);

}

for (int k = 0; k < N * N; k++) {

for (int j = 0; j < N; j++) {

w_kj[k][j] = w_kj[k][j]

- ETA

* input_layer[k]

* (1 - y_j[j] * y_j[j])

* w_ji[j]

* (1 - y_i * y_i)

* (y_i - (double) backed_up_value / (double) MAXVAL);

}

}

temp_iteration_times++;

}

return;

}

// 读取神经网络的权重，即神经网络训练的模型

// 按照写入顺序读取，数字之间用空格分开

// 两组权重为两行（第一组之后又换行符）

public void read_weight() {

String num[];

try {

String encoding = "utf-8";

// File file = new File("./../res/BP_net_weight.txt");

File file = new File(filepath);

if (file.isFile() && file.exists()) { // 判断文件是否存在

System.out.println("******************************************");

InputStreamReader read = new InputStreamReader( new FileInputStream(file), encoding);

BufferedReader bufferedReader = new BufferedReader(read);

String lineTxt = null;

lineTxt = bufferedReader.readLine();

num = lineTxt.split(" ");

for (int i = 0; i < SIZE; i++) {

w_ji[i] = Double.parseDouble(num[i]);

}

lineTxt = bufferedReader.readLine();

num = lineTxt.split(" ");

for (int i = 0; i < SIZE; i++) {

for (int j = 0; j < SIZE; j++) {

w_kj[i][j] = Double.parseDouble(num[i * SIZE + j]);

}

}

read.close();

} else {

System.out.println("read_weight 找不到指定的文件");

}

} catch (Exception e) {

System.out.println("read_weight 读取文件内容出错");

e.printStackTrace();

}

}

// 保存神经网络训练的模型

// 此函数与public void read_weight()对应

public void write_mode() {

try {

File file = new File(filepath);

file.createNewFile();

OutputStreamWriter ow = new OutputStreamWriter(new FileOutputStream(file), "utf-8");

BufferedWriter bwrite = new BufferedWriter(ow);

for (int i = 0; i < SIZE; i++) {

bwrite.write(w_ji[i] + " ");

}

bwrite.write("\n");

for (int i = 0; i < SIZE; i++) {

for (int j = 0; j < SIZE; j++) {

bwrite.write(w_kj[i][j] + " ");

}

}

bwrite.close();

} catch (Exception e) {

System.out.println("write_mode 找不到指定的文件");

}

}

}

2，Checker棋盘程序如下：

package ncse.checkerOP;

import ncse.bpNeuralNetworks.BpNeuralNetworks;

/**

* 棋盘程序

* @author guojl

*@version 20141124

*/

public class Checker {

private static int N = 4;

private static int SIZE = N * N;

// MAXVAL MINVAL 分别是默认的最大值、最小值点

private static int MAXVAL = Short.MAX_VALUE;

private static int MINVAL = Short.MIN_VALUE;

// 电脑一直使用 1 代替

// 人一直使用 -1 代替

// 在显示时，根据是否先手，确定棋子是“O” 还是“X”

private static int computer = 1; // 电脑

private static int player = -1; // 人

private int whofirst = 1; // 默认电脑先手

private int m_chess_board[]; // 棋盘，用一维数组（N * N）表

示二维数组（N，N）

private BpNeuralNetworks bpnet; // 神经网络

// 设置先手

public void setWhofirst(int whofirst) {

this.whofirst = whofirst;

}

// 初始化棋盘对象

public Checker() {

this.m_chess_board = new int[SIZE];

bpnet = new BpNeuralNetworks();

// 读取神经网络训练的模型

bpnet.read_weight();

// 清空棋盘

this.clear_board();

}

// 清空棋盘

public void clear_board() {

for (int i = 0; i < SIZE; i++) {

this.m_chess_board[i] = 0;

}

}

// 获取棋盘某一点值

// 0 : 表示没有棋子

// 1 ：表示是电脑的棋子

// -1: 表示是人的棋子

public int get_chess_board_val(int i, int j) {

return this.m_chess_board[i * N + j];

}

// 打印棋盘函数，调试用。

// 输入:void

// 返回值：void

private void print_chess_board(int[] chess_board) { int i = 0, j = 0;

for (i = 0; i < N; i++) {

for (j = 0; j < N; j++) {

if (j < N - 1) {

System.out.println(chess_board[i * N+ j] + " ");

} else {

System.out.println(chess_board[i * N + j] + "

\n");

}

}

}

return;

}

// 在棋盘(x,y)处放置棋子。棋子类型为枚举piece∈{A,B}。

// 输入：棋盘、x、y、棋子类型。

// 返回值：void

private void place_piece_on_chess_board(int[] chess_board, int x, int y,

int type) {

int pos = x * N + y;

if (pos < 16 && pos >= 0) // 防止计算结果出错，导致数组越界

chess_board[x * N + y] = type;

else {

// 如果计算结果越出数组大小，打印当前 x, y值

// 调试用

System.out.println("x = " + x + " y = " + y);

}

}

// 功能同重载函数

// 不同点为，此函数默认对当前棋盘操作

// 是对外提供的在棋盘上下棋子的接口函数

public void place_piece(int x, int y, int type) {

place_piece_on_chess_board(this.m_chess_board, x, y, type);

}

// 测试指定起点与步长的N个数数否相等，相等返回数值

// 否则返回0

// 用于判断当前棋盘是否有N个相同的棋子连续

private int test_N_num_equal(int[] chess_board, int start, int step) {

/*

* 原理：一行棋子相同，则是在数组中 N 倍数点起始连续N个点相同且不是0

* 一列棋子相同，则是判断前N个点中某一点起始，隔N的倍数个点的值都相同且不为0

* 对角线，间隔分别是：主对角线（N+1）

* 次对角线（N-1）

* 以上判断，都是相隔固定个点，

* */

int i = 0;

int check_flag = 1;

for (i = 0; i < N - 1; i++) {

if (chess_board[start + i * step] != chess_board[start + (i + 1)

* step]) {

check_flag = 0;

break;

}

}

if (check_flag == 1 && chess_board[start + i * step] != 0) {

return chess_board[start + i * step];

}

return 0;

}

// 测试当前棋局谁赢。

// 输入：棋盘。

// 返回值：为0表示A、B都没赢，为1表示A胜，为-1表示B胜。

private int test_who_win(int[] chess_board) {

// 分别测试一行、一列、两个对角线连成一线四种情况下的输赢

int ret = 0;

for (int i = 0; i < N; i++) {

// 行

ret = test_N_num_equal(chess_board, (i * N), 1);

if (ret != 0)

return ret;

// 列

ret = test_N_num_equal(chess_board, i, N);

if (ret != 0)

return ret;

}

// 主对角线

ret = test_N_num_equal(chess_board, 0, (N + 1));

if (ret != 0)

return ret;

// 次对角线

ret = test_N_num_equal(chess_board, (N - 1), (N - 1));

if (ret != 0)

return ret;

return 0;

}

// 同private int test_who_win(int[] chess_board)

// 此函数式对外提供的接口函数

public int who_win() {

return test_who_win(this.m_chess_board);

}

// 测试当前棋盘（博弈树结点）属于极大结点或极小结点。

// 输入：棋盘。

// 返回值：为1表示当前为极大结点，为-1表示当前为极小结点。

private int test_node_type(int[] chess_board) {

// 可以用当前双方棋子数量来判断极大/极小结点

int count_of_computer = 0, count_of_player = 0;

int i = 0;

// 对棋盘双方棋子计数

for (i = 0; i < SIZE; i++) {

if (chess_board[i] == computer) {

count_of_computer++;

} else if (chess_board[i] == player) {

count_of_player++;

}

}

// 相等，返回先手值

// 否则，返回棋子少的一方

if (count_of_computer == count_of_player){

return whofirst;

}else if (count_of_computer > count_of_player) { return player;

} else {

return computer;

}

}

// 测试棋盘是否下满。

// 输入：棋盘。

// 返回值：下满返回true，否则返回false。

private boolean test_if_chess_board_full(int[] chess_board) { int i = 0;

for (i = 0; i < SIZE; i++) {

if (chess_board[i] == 0) {

return false;

}

}

return true;

}

// 同private boolean test_if_chess_board_full(int[]

chess_board)

// 此函数是对外提供的接口函数

public boolean is_chess_board_full() {

return test_if_chess_board_full(this.m_chess_board);

}

// 评估函数。

// 输入：当前棋局。

// 返回值：棋局对应评估函数值。

private int evaluation_function(int[] chess_board) { if (test_who_win(chess_board) == 1) {

// 电脑赢返回最大值表示极大值

return MAXVAL;

} else if (test_who_win(chess_board) == -1) {

// 人赢，返回最小值表示极小值

return MINVAL;

} else {

// 否则，用神经网络计算评估

int temp = (int)(bpnet.BP_net_value(chess_board) * MAXVAL);

return temp;

}

}

// 复制棋盘。将chess_board2赋给chess_board1。

// 输入：两个棋盘向量。

// 返回值：void

private void copy_chess_board(int[] dest_board, int[]

src_board) {

int i = 0;

for (i = 0; i < SIZE; i++) {

dest_board[i] = src_board[i];

}

return;

}

// 初始化祖先数组。祖先数组用于α-β剪枝。

// 输入：祖先数组、当前节点类型（极大或极小结点）。

// 返回值：void

private void init_ancestor(int[] ancestor, int node_type) { int i = 0;

node_type = (node_type + 1) == 2 ? node_type : 0;

// 必须将极大结点的初值置为MIN、极小为MAXVAL，以便α-β剪枝时能够改变它们的值

for (i = 0; i < SIZE; i++) {

if (i % 2 == node_type) {

ancestor[i] = MAXVAL;

} else {

ancestor[i] = MINVAL;

}

}

}

// 搜索当前结点倒推值。

// 输入：当前棋局、默认深度（默认为0）、最大深度、祖先数组、当前结点类型。

// 返回值：棋局倒推值。

private int get_backed_up_value_of_node(int[] chess_board, int h,

int depth, int[] ancestor, int root_type) {

int i = 0, j = 0;

if (h == depth || test_if_chess_board_full(chess_board) || test_who_win(chess_board) != 0) {

// 如果是叶子结点，返回评估值（神经网络在评估值中）

return evaluation_function(chess_board);

} else {

int backed_up_value;

int node_type = 0;

int t_chess_board[] = new int[SIZE];

int usr_no = 0;

int node_value = -1;

int max_node_value = MINVAL, min_node_value = MAXVAL;

for (i = 0; i < SIZE; i++) {

if (chess_board[i] == 0) {

/*

* 递归调用自身，向后探测 depth 步，对当前棋局进行评估，选择最佳步骤

* */

copy_chess_board(t_chess_board, chess_board);

place_piece_on_chess_board(t_chess_board, (i / N), (i % N),

test_node_type(chess_board));

backed_up_value = get_backed_up_value_of_node(

t_chess_board, (h + 1), depth, ancestor, root_type);

node_type = test_node_type(chess_board);

usr_no = (node_type + 1) == 2 ? node_type : 0;

// 当前点是电脑，评估值为极大值点

if (node_type == computer) {

if (backed_up_value > max_node_value) {

max_node_value = backed_up_value;

}

node_value = max_node_value;

} else {

// 当前节点人，则是极小值点

if (backed_up_value < min_node_value) {

min_node_value = backed_up_value;

}

node_value = min_node_value;

}

// 根据各祖先结点的α或β值来剪枝

// 此处，由于node_type可为-1、1两种情况，

// 故将极大极小乘node_type后，可以合并看待

boolean continue_search = true;

for (j = 0; j < h; j++) {

if ((node_type * node_value) > (node_type * ancestor[j])) {

continue_search = false;

break;

}

}

if (continue_search == false) {

break;

}

}

}

// 完成叶子结点的搜索后，更新各祖先的α-β值

if (h - 1 >= 0) {

int flag = (node_type == root_type) ? 1 : -1;

if ((h - 1) % 2 != usr_no) {

if((flag * node_value) > (flag * ancestor[h - 1])) {

ancestor[h - 1] = node_value;

}

} else {

if((flag * node_value) < (flag * ancestor[h - 1])) {

ancestor[h - 1] = node_value;

}

}

}

return node_value;

}

}

public int get_next_step() {

int i = 0;

int max = MINVAL - 1;

int step = -1;

int back_up_val;

int t_chess_board[] = new int[SIZE];

int ancestor[] = new int[SIZE];

for (i = 0; i < SIZE; i++) {

if (this.m_chess_board[i] != 0) {

continue;

}

/*

* 向后探测8步，选择最佳步骤

* */

copy_chess_board(t_chess_board, this.m_chess_board);

init_ancestor(ancestor,

test_node_type(t_chess_board));

place_piece_on_chess_board(t_chess_board, (i / N), (i % N), computer);

back_up_val =

get_backed_up_value_of_node(t_chess_board, 0, 8,

ancestor, test_node_type(t_chess_board));

// System.out.println("back_up_val is " + back_up_val + " at "

// + (i / N) + ", " + (i % N) + " \n");

if (back_up_val > max) {

max = back_up_val;

step = i;

}

}

return step;

}

public void train_mode() {

// 以下是用机器学习/调整神经网络的代码进行模型训练

// 通过随机生成棋局并计算其倒退值，让神经网络调整权重，

// 即对战双方都是电脑

int computer1 = -1;

int computer2 = 1;

try {

int learn_times = 10;

int temp_learn_times = 0;

bpnet.init_weight();

while(true) {

int count = 0;

this.clear_board();

this.whofirst = computer1;

while(!this.test_if_chess_board_full(this.m_chess_board) &&

this.test_who_win(this.m_chess_board) == 0) { while(count < SIZE) {

int temp = ((int)Math.random()*100) % (SIZE);

if (this.m_chess_board[temp] == 0) {

if (count % 2 == 0) {

this.place_piece_on_chess_board(this.m_chess_board, (temp / N), (temp % N), computer1);

} else {

this.place_piece_on_chess_board(this.m_chess_board, (temp / N), (temp % N), computer2);

}

break;

}

}

count ++;

if (count >= 8) {

int ancestor[] = new int[Checker.SIZE];

init_ancestor(ancestor,

test_node_type(this.m_chess_board));

int backed_up_value =

get_backed_up_value_of_node(this.m_chess_board, 0, 8, ancestor, test_node_type(this.m_chess_board));

bpnet.adjust_BP_net_weight(this.m_chess_board,

backed_up_value);

temp_learn_times ++;

System.out.println("learn " + temp_learn_times + " times.\n");

}

}

if (temp_learn_times >= learn_times) {

break;

}

}

bpnet.write_mode();

} catch (Exception e) {

e.printStackTrace();

}

}

}

3，ChessUI主界面程序如下：

package ncse.chessgui;

import java.awt.*;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.event.MouseEvent;

import java.awt.event.MouseListener;

import javax.swing.*;

import ncse.checkerOP.*;

/**

* 主界面

* @author guojl

*@version 20141124

*/

public class ChessUI extends JFrame implements ActionListener { private static final long serialVersionUID = -8038284356203129896L;

private PicPanel p;

// 菜单栏菜单菜单项

private JMenuBar menuBar;

private JMenu menu;

private JMenuItem mItemPalyer;

private JMenuItem mItemComputer;

public ChessUI() {

this.setSize(641, 661);

this.setTitle("Tic Tac Toe");

menu = new JMenu("options");

mItemPalyer = new JMenuItem("人先下");

mItemComputer = new JMenuItem("电脑先下");

mItemPalyer.addActionListener(this);

mItemComputer.addActionListener(this);

menu.add(mItemPalyer);

menu.add(mItemComputer);

menuBar = new JMenuBar();

menuBar.add(menu);

this.add(menuBar, BorderLayout.NORTH);

// 初始化一个棋盘界面

p = new PicPanel();

p.setLayout(new FlowLayout());

this.add(p, BorderLayout.CENTER);

this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

this.setVisible(true);

}

@Override

public void actionPerformed(ActionEvent e) {

Object eventSource = e.getSource();

// 菜单选择谁先手

if (eventSource == mItemComputer) {

https://www.360docs.net/doc/1515876426.html,puter_first();

} else if (eventSource == mItemPalyer) {

p.player_first();

}

}

}

class PicPanel extends JPanel implements MouseListener {

private static final long serialVersionUID = 5000731934873447636L;

private static int N = 4;

private String bgpath = null;

private String iconXpath = null;

private String iconOpath = null;

private ImageIcon iconX; // X 棋子图标

private ImageIcon iconO; // O 棋子图标

private ImageIcon playerIcon; // 用户棋子图标

private ImageIcon computerIcon; // 电脑棋子图标

private int player = -1;

private int computer = 1;

private Checker checker; // 棋盘

private boolean startflag = false;

// 棋盘上所有棋子图标位置

private int draw_position[][] = { { 20, 23 }, { 176, 23 }, { 332, 23 }, { 488, 23 }, { 20, 172 }, { 176, 172 }, { 332, 172 }, { 488, 172 },

{ 20, 320 }, { 176, 320 }, { 332, 320 }, { 488, 320 },

{ 20, 468 }, { 176, 468 }, { 332, 468 }, { 488, 468 } };

// 每条竖线的位置以及左右边界

private int tell_positionX[] = { 0, 176, 332, 488, 625 };

// 每条横线的位置以及上下边界

private int tell_positionY[] = { 0, 172, 320, 468, 596 };

public PicPanel() {

bgpath = "image/background.jpg";

iconXpath = "image/X.png";

iconOpath = "image/O.png";

https://www.360docs.net/doc/1515876426.html,.URL imgXURL = getClass().getResource(iconXpath);

// https://www.360docs.net/doc/1515876426.html,.URL imgXURL = getClass().getResource(".");

// System.out.println("" + imgXURL);

iconX = new ImageIcon(imgXURL);

https://www.360docs.net/doc/1515876426.html,.URL imgOURL = getClass().getResource(iconOpath);

iconO = new ImageIcon(imgOURL);

checker = new Checker();

this.addMouseListener((MouseListener) this);

}

// 获取当前点所在属于哪个棋子的位置