我想用机器学习方法解决的情况示例

Question

我想开始学习一些有关机器学习的知识，我决定从一个实际示例/问题开始，稍后我会解释，但首先我更愿意告诉你：

1. 我不是程序员（我对 Python 有所了解）。
2. 我将描述的游戏是一个示例，实际上我更感兴趣的是了解如何将标准方法用于 ML，该方法尽可能独立于我想要解决的游戏或问题（如果可能的话）。

让我们开始吧。

游戏描述如下：

1. 我们有一个矩形 LxH（L 可以等于 H），其中有两个玩家 A 和 B（它们是两个像素或两个小图形圆圈）。
2. 玩家 A 必须从起始位置（随机）移动到结束位置，并且结束位置是靠近 A 的矩形边框，这样玩家 B 在比赛开始时位于玩家 A 和该边框之间。李>
3. 玩家 B 必须从开始位置（随机）移动到结束位置，并且结束位置是玩家 A 的位置。
4. 如果玩家 A 在没有被玩家 B 接触的情况下到达矩形的边界（参见第 2 点），则 A 赢，B 输。
5. 如果玩家 B 在 A 到达矩形边界之前接触到玩家 A（参见第 2 点），则 A 输，B 赢。

游戏的单轮/比赛定义为玩家 A 和 B 从起始位置（随机）到结束位置（对于玩家 A，在第 2 点描述的边界，对于玩家 B，在第 2 点描述的边界）执行的一组动作玩家 A) 的相同位置。模拟被定义为一组比赛，人工智能可以从这些比赛中自我改进，并越来越多地了解如何移动更好的球员 A 和球员 B，以便在更短的时间内获得 A 或 B 的胜利。

好吧，我想用机器学习方法模拟这个简单的游戏，以便：

一个。第一次开始游戏，完全随机选择玩家 A 和 B 的下一个位置：结果，我会看到 A 和 B 没有任何意义的混乱动作。

b.在一些比赛之后，该算法应该从之前的比赛中学习一些东西，以便将玩家 A 主要移动到获胜边界，将玩家 B 主要移动到玩家 A。

c。在进行了足够多的比赛之后，即在模拟之后，我想要一组由 AI 创建的规则（例如，每种情况下的最佳位置值表），当玩家B 由用户移动，而不是由算法/计算机移动（只有玩家 A 由计算机使用先前完成的模拟中刚刚创建的 AI 移动）。

例如，对于 b 点，我想不出任何可以帮助我的东西。也许我可以使用一个时间约束，即：如果一段时间后玩家 A 或玩家 B 没有从自己的起始位置转身超过 X 像素，那么给玩家 A 的获胜边界方向赋予更大的权重，并赋予更大的权重。在单场比赛中为双方选择新位置时，对球员 A 的权重为球员 B 的方向。但在这种情况下，这将是程序员添加的强制动作，而不是来自简单游戏规则的人工智能的真正改进。还是不行？

最后，您能否帮助我理解如何处理我描述的问题（推理、思维方法、python 工具、库、与我的问题类似的现有示例代码等）？

感谢任何回复，这些回复将帮助我从实际问题开始更多地了解 ML。

马特奥

更新 01：

我在这里发布了一个 python (Python 2.7) 脚本，它在模拟过程中绘制玩家 A 的路径：

from __future__ import division
from numpy.random import choice
import numpy as np
import matplotlib.pyplot as plt
import random
import sys   #sys.exit()
import time
import operator
import math



## parameters:
number_of_matches = 100   # for one simulation
max_number_of_movements_in_single_match = 100
directions = [1, 2, 3, 4]   #1=up, 2=left, 3=down, 4=right
weights = [0.25, 0.25, 0.25, 0.25]
up_direction_weight = weights[0]
rectangle_width = 8   #x
rectangle_lenght = 12   #y
plot_expiration = 0.01   # seconds



## initialization:
vector_i = []
direction_i = []
half_rectangle_width = rectangle_width/2   #x
half_rectangle_lenght = rectangle_lenght/2   #y



## main code:
for j in range(number_of_matches):   #j=single match

    ax = plt.gca()
    ax.set_aspect(aspect=1)
    ax.set_xlim([0,rectangle_width])
    ax.set_ylim([0,rectangle_lenght])

    plt.text(0, rectangle_lenght+1.5, 'match number: ' + str(j+1), fontsize=10)
    plt.text(0, rectangle_lenght+0.5, 'weights: ' + str(np.around(weights, decimals=2)), fontsize=10)




    x = []
    y = []
    x_init = int(0 + (rectangle_width)*random.random())
    #y_init = int(0 + (half_rectangle_lenght)*random.random())
    y_init = int(0 + (rectangle_lenght)*random.random())


    x.append(x_init)
    y.append(y_init)

    i=0
    while True:   #inside it we calculate the directions for player A in the match j

        plt.scatter(x, y, s=4)
        plt.plot(x, y)
        plt.pause(plot_expiration)



        if y_init == rectangle_lenght:   # if the upper border of rectangle has been reached by player A, calculate new weights array for match j+1, the match j ends
            number_of_up_directions = direction_i.count(1)   # to know how many up directions in match j
            var1 = number_of_up_directions / i
            if var1 > up_direction_weight:
                var2 = 1 - var1
                var3 = var2 / 3
                weights = [var1, var3, var3, var3]
                up_direction_weight = var1
            direction_i = []
            x = []
            y = []
            x_init=half_rectangle_width
            y_init=half_rectangle_lenght
            x.append(x_init)
            y.append(y_init)
            break   # exit from match j to start next match j+1

        if i >= max_number_of_movements_in_single_match:   # if single match takes too time, exit from match j to start next match j+1
            direction_i = []
            x = []
            y = []
            x_init=half_rectangle_width
            y_init=half_rectangle_lenght
            x.append(x_init)
            y.append(y_init)
            break   # exit from match j to start next match j+1

        i=i+1   # next position for player A in the match j


        # weighed random choise/calculation of the direction for player A in the match j
        direction = choice(directions, p=weights)
        direction_i.append(direction)


        # update position of player A in match j, according to geometric constraints
        if direction == 1:
            y_new = y_init + 1
            if y_new >= 0 and y_new <= rectangle_lenght:
                x.append(x_init)
                y.append(y_new)
                y_init = y_new
            else:
                x.append(x_init)
                y.append(y_init)

        if direction == 2:
            x_new = x_init - 1
            if x_new >= 0 and x_new <= rectangle_width:
                x.append(x_new)
                y.append(y_init)
                x_init = x_new
            else:
                x.append(x_init)
                y.append(y_init)

        if direction == 3:
            y_new = y_init - 1
            if y_new >= 0 and y_new <= rectangle_lenght:
                x.append(x_init)
                y.append(y_new)
                y_init = y_new
            else:
                x.append(x_init)
                y.append(y_init)

        if direction == 4:
            x_new = x_init + 1
            if x_new >= 0 and x_new <= rectangle_width:
                x.append(x_new)
                y.append(y_init)
                x_init = x_new
            else:
                x.append(x_init)
                y.append(y_init)


    plt.show(block=False)
    time.sleep(plot_expiration)
    plt.close()


print(weights)

代码远未优化，无法重现我在原始问题中提出的问题，但这是第一次尝试在没有任何大型复杂库（如 TensorFlow、Unity 等）的情况下运行。这很简单，它在几场比赛中绘制玩家 A 的路径（参见我的原始问题），当玩家 A 到达矩形的上边界时，代码会更新方向权重数组。

AI 从 4 个可能的方向 [上、左、下、右] 中随机选择一个方向开始。

我用这种类型的 AI 可以获得的最佳结果（基于如果 A 到达上边界时给予向上方向的奖励，向上方向的权重是比赛中所有方向的加权平均值），是权重数组[1,0,0,0]，即玩家A“了解到”它可以通过沿着垂直路径在更短的时间内（并且能量损失更少）到达上边界。这很简单。

我的问题与玩家 B 有关：它必须“学习”去玩家 A 所在的位置。如果 B 与 A 处于同一位置，则 B 获胜。 你对玩家 B 的学习 AI 有什么建议？ 请注意，现在我不想给玩家 A 一个更聪明的 AI，对我来说它到达边界就足够了最少的移动次数（垂直路径）。

例如（我期望的答案示例）：

1. 玩家 B 一开始可能有随机方向，但每次与玩家 A 的路径相交时，为 B 选择的每个新方向给方向 B->A 赋予更多权重。
2. 玩家 B 一开始可能有随机方向，但每次玩家 B 移动时，根据 A 和 B 之间的距离，给方向 B->A 赋予更多权重。
3. ...

谢谢

Answer 1

如果您想在回合制游戏中使用该算法（意味着玩家轮流执行动作），那么您可以使用 Minimax 算法。它是有史以来最好的算法，并且易于解释和实现 你可以从here找到一个井字游戏中Minimax算法的实现