小编Den*_*ers的帖子

Lime来源:https://github.com/marcotcr/lime

treeinterpreter source:树解释器

我试图了解如何 DecisionTree使用Lime和treeinterpreter进行预测.虽然两者都声称他们能够在他们的描述中解释决策树.似乎两者都以DecisionTree不同的方式解释相同.即,特征贡献顺序.怎么可能？如果两者都在看同样的事情,并试图描述相同的事件,但按差异顺序分配重要性.

我们应该信任谁？特别是顶部特征在预测中很重要.

树的代码

import sklearn
import sklearn.datasets
import sklearn.ensemble
import numpy as np
import lime
import lime.lime_tabular
from __future__ import print_function
np.random.seed(1)
from treeinterpreter import treeinterpreter as ti
from sklearn.tree import DecisionTreeClassifier

iris = sklearn.datasets.load_iris()

dt = DecisionTreeClassifier(random_state=42)                
dt.fit(iris.data, iris.target)

n = 100


instances =iris.data[n].reshape(1,-1)

prediction, biases, contributions = ti.predict(dt, instances)


for i in range(len(instances)):
    print ("prediction:",prediction)
    print ("-"*20) 
    print ("Feature contributions:")
    print ("-"*20) 

    for c, feature …

编辑:以下似乎也是如此FrozenLake-v0.请注意,我对简单的Q学习不感兴趣,因为我希望看到适用于连续观察空间的解决方案.

我最近创建了banana_gymOpenAI环境.方案如下:

你有一根香蕉.它必须在2天内出售,因为它在第3天会很糟糕.您可以选择价格x,但香蕉只会以概率出售

奖励为x - 1.如果第三天没有出售香蕉,则奖励为-1.(直觉:你为香蕉付了1欧元).因此,环境是非确定性的(随机的).

操作:您可以将价格设置为{0.00,0.10,0.20,...,2.00}中的任何值

观察:剩余时间(来源)

我计算了最优政策:

Opt at step  1: price 1.50 has value -0.26 (chance: 0.28)
Opt at step  2: price 1.10 has value -0.55 (chance: 0.41)

这也符合我的直觉:首先尝试以更高的价格出售香蕉,因为如果你不卖它,你知道你还有另一种尝试.然后将价格降低到0.00以上.

最优政策计算

我很确定这个是正确的,但为了完整起见

#!/usr/bin/env python

"""Calculate the optimal banana pricing policy."""

import math
import numpy as np


def main(total_time_steps, price_not_sold, chance_to_sell):
    """
    Compare the optimal policy to a given policy.

    Parameters
    ----------
    total_time_steps : int
        How often the agent may offer …

此代码不起作用......

self._thread = threading.Timer(interval=2, 
                               function=self._sendRequestState, 
                               args=(self._lockState,), 
                               daemon=True).start()

所以我应该这样写..

self._thread = threading.Timer(interval=2, 
                               function=self._sendRequestState, 
                               args=(self._lockState,))
self._thread.daemon = True
self._thread.start()

但是Timer该类有Thread.__init__,Thread.__init__有“ daemon”作为输入参数。我不知道为什么它不起作用......

是)我有的:

• 一个包含许多行的数据帧,以及几个现有列(python,pandas).
• Python 3.6,所以依赖于特定版本的解决方案对我来说很好(但显然也适用于早期版本的解决方案也很好)

我想做的事:

• 向数据框添加多个附加列,其中这些新列中的值都取决于同一行中现有列中的值的某些方式.
• 必须保留数据帧的原始顺序.如果解决方案改变了排序,我可以通过基于其中一个现有列手动排序来恢复它,但显然这会带来额外的开销.

我已经有以下代码,它可以正常工作.但是,分析表明此代码是我的代码中的重要瓶颈之一,所以我想尽可能优化它,我也有理由相信应该是可能的:

df["NewColumn1"] = df.apply(lambda row: compute_new_column1_value(row), axis=1)
df["NewColumn2"] = df.apply(lambda row: compute_new_column2_value(row), axis=1)

# a few more lines of code like the above

我基于这个答案解决这样的问题这一个(这是与我相似,但具体如何添加一个新列的问题,而我的问题是关于添加了许多新的列).我想这些df.apply()调用中的每一个都是通过所有行的循环在内部实现的,我怀疑应该可以使用只循环所有循环一次的解决方案来优化它(而不是每列需要添加一次) ).

在其他答案中,我看到了对assign()函数的引用,它确实支持一次添加多个列.我尝试以下列方式使用它:

# WARNING: this does NOT work
df = df.assign(
    NewColumn1=lambda row: compute_new_column1_value(row),
    NewColumn2=lambda row: compute_new_column2_value(row),
    # more lines like the two above
)

这不起作用的原因是因为lambda实际上根本没有接收到数据帧的行,它们似乎只是立刻得到整个数据帧.然后期望每个lambda一次返回完整的列/ Series /数组值.所以,我的问题是,我必须最终在这些lambda中通过所有循环实现手动循环,这显然会对性能更糟.

我可以从概念上考虑两种解决方案,但到目前为止还无法找到如何实际实现它们:

1. 类似的东西df.assign()(支持一次添加多个列),但能够将行传递到lambda而不是完整的数据帧

2. 一种向我的compute_new_columnX_value()函数进行向量化的方法,以便它们可以像df.assign()预期的那样用作lambda .

到目前为止我的第二个解决方案的问题是基于行的版本我的一些函数看起来如下,我很难找到如何正确地向量化它们:

def compute_new_column1_value(row):
    if row["SomeExistingColumn"] …

这是我在 python 中的第一个代码，我有这个问题：

我正在阅读一个二进制文件：

def read_file(file):
    with open(file, "rb") as f:
        frame = f.read()
        print(type(frame)) #out = <class 'bytes'>
        return frame

我需要将所有向量转换为 int 值，而不是将它们用作字节。

打印后我得到这样的东西：

print(frame[0:10])
b'\xff\xff\xff\xffXabccc'

但是，如果我只打印通过一个位置，我会得到这个:(整数值是正确的，但我只是使用函数打印来获取它们）

print(frame[0])
255    
print(frame[1])
255
print(frame[2])
255
print(frame[3])
255
print(frame[4])
88
print(frame[5])
97
print(frame[6])
98
print(frame[7])
99
print(frame[8])
99
print(frame[9])
99
print(frame[10])
98

问题是：如何一步转换数组的所有位置？我想运行代码

print(frame[0:10])

并得到类似的东西

[255, 255, 255, 255, 88, 97, 98, 99 ,99, 99, 98]

我正在尝试实现一个 Q 学习代理来学习在井字游戏中与随机代理对战的最佳策略。

我制定了一个我相信会奏效的计划。只有一个部分我无法理解。这是因为环境中有两个玩家。

现在，Q Learning 代理应该对当前状态s采取行动，给定一些策略采取a的行动，给定动作的连续状态s'，以及从该连续状态收到的任何奖励，r。

让我们把它放到一个元组中 (s, a, r, s')

现在通常一个代理会对它在给定动作中遇到的每个状态采取行动，并使用 Q 学习方程来更新前一个状态的值。

然而，由于 Tic Tac Toe 有两个玩家，我们可以将状态集分成两个。一组状态可以是学习代理开始采取行动的状态。另一组状态可以是对手开始行动的地方。

那么，我们是否需要将状态一分为二？或者学习代理是否需要更新游戏中访问的每个状态？

I feel as though it should probably be the latter, as this might affect updating Q Values for when the opponent wins the game.

Any help with this would be great, as there does not seem to be anything online that helps with my predicament.

我在一定程度上理解算法的工作原理.我不完全理解的是算法是如何在实践中实际实现的.

我有兴趣了解一个相当复杂的游戏(也许是象棋)的最佳方法.即递归方法？异步？同时？平行？分散式？数据结构和/或数据库？

- 我们期望在一台机器上看到什么类型的限制？(我们可以同时在多个核心上运行......也许是gpu？)

- 如果每个分支都会产生一个全新的游戏,(这可能达到数百万)我们如何保持整个系统的稳定？我们如何重用已经播放的分支？

假设我们要计算向量与其自身的外积：

import numpy as np

a = np.asarray([1, 1.5, 2, 2.5, 3])
A = np.outer(a, a)

print(A)

结果是：

[[ 1.    1.5   2.    2.5   3.  ]
 [ 1.5   2.25  3.    3.75  4.5 ]
 [ 2.    3.    4.    5.    6.  ]
 [ 2.5   3.75  5.    6.25  7.5 ]
 [ 3.    4.5   6.    7.5   9.  ]]

这导致对称矩阵。可以通过仅计算矩阵的一个三角形并从三角形中的相应条目填充剩余条目来利用外积中的两个向量相同这一事实的先验知识。

问题：有没有简单的方法可以在numpy（或Python中的其他解决方案）中利用这些知识？当然，用 Python 编写自定义解决方案并不会太困难，但如果这是以不使用可靠的 BLAS 为代价的话，那就不太值得了。

我主要关心的是计算时间，而不是 RAM 使用情况。

尝试使用像这样的 YouTube 视频和论文来学习 MCST。

http://www0.cs.ucl.ac.uk/staff/D.Silver/web/Applications_files/grand-challenge.pdf

然而，除了高级理论解释之外，我并没有多少运气来理解细节。这是上面论文的一些引述和我的问题。

1. 选择阶段：MCTS 迭代选择当前状态得分最高的子节点。如果当前状态是根节点，那么这些孩子首先来自哪里？你不会有一棵只有一个根节点的树吗？只有一个根节点，您是否会立即进入扩展和模拟阶段？

2. 如果 MCTS 在选择阶段选择得分最高的子节点，那么在沿着树的级别向下时，您永远不会探索其他子节点甚至可能是全新的子节点？

3. 节点的扩展阶段如何发生？上图中，为什么不选择叶子节点而是决定给叶子节点添加一个兄弟节点呢？

4. 在模拟阶段，随机策略用于为两个玩家选择合法的移动，直到游戏终止。这种随机策略是否是一种硬编码行为，并且您基本上是在模拟中掷骰子以选择每个玩家之间轮流直到最后的可能动作之一？

5. 我的理解是从单个根节点开始，通过重复上述阶段将树构建到一定深度。然后你选择第二级得分最好的孩子作为你的下一步。您愿意构建的树的大小基本上是您的硬 AI 响应要求，对吗？因为在构建树时，游戏将停止并计算这棵树。

我尝试使用Tensorflow和OpenAI的Gym来编写Deep Q网络来玩Atari游戏.这是我的代码:

import tensorflow as tf
import gym
import numpy as np
import os

env_name = 'Breakout-v0'
env = gym.make(env_name)
num_episodes = 100
input_data = tf.placeholder(tf.float32,(None,)+env.observation_space.shape)
output_labels = tf.placeholder(tf.float32,(None,env.action_space.n))

def convnet(data):
    layer1 = tf.layers.conv2d(data,32,5,activation=tf.nn.relu)
    layer1_dropout = tf.nn.dropout(layer1,0.8)
    layer2 = tf.layers.conv2d(layer1_dropout,64,5,activation=tf.nn.relu)
    layer2_dropout = tf.nn.dropout(layer2,0.8)
    layer3 = tf.layers.conv2d(layer2_dropout,128,5,activation=tf.nn.relu)
    layer3_dropout = tf.nn.dropout(layer3,0.8)
    layer4 = tf.layers.dense(layer3_dropout,units=128,activation=tf.nn.softmax,kernel_initializer=tf.zeros_initializer)
    layer5 = tf.layers.flatten(layer4)
    layer5_dropout = tf.nn.dropout(layer5,0.8)
    layer6 = tf.layers.dense(layer5_dropout,units=env.action_space.n,activation=tf.nn.softmax,kernel_initializer=tf.zeros_initializer)
    return layer6

logits = convnet(input_data)
loss = tf.losses.sigmoid_cross_entropy(output_labels,logits)
train = tf.train.GradientDescentOptimizer(0.001).minimize(loss)
saver = tf.train.Saver()
init = tf.global_variables_initializer()
discount_factor = …

我正在尝试创建一个程序来打印1 <= n <= 13n 皇后问题的所有解决方案。该程序将n从命令行读取一个整数，指示要解决的皇后问题的大小。例如，如果n = 5它会打印出

(1, 3, 5, 2, 4)
(1, 4, 2, 5, 3)
(2, 4, 1, 3, 5)
(2, 5, 3, 1, 4)
(3, 1, 4, 2, 5)
(3, 5, 2, 4, 1)
(4, 1, 3, 5, 2)

(4, 2, 5, 3, 1)
(5, 2, 4, 1, 3)
(5, 3, 1, 4, 2)

目前，我只停留在程序的一项功能上。我需要创建一个方法，如果 (A[1], A[2], A[3], ..., A[n]) 表示的排列没有放置两个皇后（棋子），该方法将返回 true相同的对角线，否则返回 false。为了检查 (A[i], i) 和 (A[j], j) 处的两个皇后是否位于同一条对角线上，我需要检查水平距离是否与垂直距离相同。

该函数被调用 …