小编r0f*_*0f1的帖子

有没有办法在Jupyter笔记本中绘制决策树,以便我可以交互式地探索它的节点？我在考虑这样的事情.这是KNIME的一个例子.

我找到了https://planspace.org/20151129-see_sklearn_trees_with_d3/和https://bl.ocks.org/ajschumacher/65eda1df2b0dd2cf616f,我知道你可以在Jupyter中运行d3,但是我没有找到任何包,那样做.

考虑以下图像，存储为 numpy 数组：

a = [[0,0,0,0,0,1,1,0,0,0],
     [0,0,0,0,1,1,1,1,0,0],
     [0,0,0,0,0,1,1,0,0,0],
     [0,0,0,0,0,0,0,0,0,0],
     [0,0,0,0,0,2,0,0,0,0],
     [0,0,0,0,0,2,2,0,0,0],
     [0,0,0,0,0,2,0,0,0,0],
     [0,0,0,0,3,3,3,0,0,0],
     [4,0,0,0,0,0,0,0,0,0],
     [4,4,0,0,0,0,0,0,0,0],
     [4,4,4,0,0,0,0,0,0,0]]

a = np.array(a)

零代表背景像素，1、2、3 和 4 代表属于对象的像素。您可以看到对象总是在图像中形成连续的岛屿或区域。我想知道每对物体之间的距离。作为距离度量，我希望在对象的那些像素之间具有最短的直线距离，它们彼此最接近。示例：Distance(2,3) = 1，因为它们在接触。Distance(1,2) = 2，因为正好有一个背景像素将两个区域分开，或者换句话说，对象的最近像素相隔两个像素。

谁能告诉我如何在 Python 中解决这个问题？或者给我链接一些资源？

我正在做主成分分析 (PCA)，我想找出对结果贡献最大的特征。

我的直觉是总结特征对单个组件的单个贡献的所有绝对值。

import numpy as np
from sklearn.decomposition import PCA

X = np.array([[-1, -1, 4, 1], [-2, -1, 4, 2], [-3, -2, 4, 3], [1, 1, 4, 4], [2, 1, 4, 5], [3, 2, 4, 6]])
pca = PCA(n_components=0.95, whiten=True, svd_solver='full').fit(X)
pca.components_

array([[ 0.71417303,  0.46711713,  0.        ,  0.52130459],
       [-0.46602418, -0.23839061, -0.        ,  0.85205128]])

array([[ 0.71417303,  0.46711713,  0.        ,  0.52130459],
       [-0.46602418, -0.23839061, -0.        ,  0.85205128]])

array([1.18019721, 0.70550774, 0.        , 1.37335586])

在我看来，这可以衡量每个原始特征的重要性。请注意，第三个特征的重要性为零，因为我有意创建了一个只是一个常量值的列。

PCA 是否有更好的“重要性衡量标准”？

给定以下数据框：

import pandas as pd

pd.DataFrame({"start": ["2017-01-01 13:09:01", "2017-01-01 13:09:07", "2017-01-01 13:09:12"],
         "end":    ["2017-01-01 13:09:05", "2017-01-01 13:09:09", "2017-01-01 13:09:14"],
         "status": ["OK", "ERROR", "OK"]})

有：

| start               | end                 | status |
|---------------------|---------------------|--------|
| 2017-01-01 13:09:01 | 2017-01-01 13:09:05 | OK     |
| 2017-01-01 13:09:07 | 2017-01-01 13:09:09 | ERROR  | 
| 2017-01-01 13:09:12 | 2017-01-01 13:09:14 | OK     |

我想将其转换为另一种格式，即“展开”间隔并将它们转换为 DatetimeIndex，然后重新采样数据。结果应如下所示：

想：

|                     | status    |
|---------------------|-----------|
| 2017-01-01 13:09:01 | OK        |
| 2017-01-01 13:09:02 | OK        |
| …

我有一个正在运行的 Google 深度学习 VM，我设置了一个 SSH 隧道，当我导航到http://localhost:8080时，我连接到正在运行的 Jupyter Lab 实例。运行命令sudo service jupyter status，告诉我服务运行正常。

现在，我想使用 Visual Studio Code 连接到 Jupyter 实例。我尝试了 [Ctrl]+[Shift]+[P] 和“Python：指定 Jupyter 服务器 URI”，并在出现的提示中输入http://localhost:8080 。但是，我收到一条错误消息：

Failed to connect to remote Jupyter notebook.
Check that the Jupyter Server URI setting has a valid running server specified.
http://localhost:8080/
Error: Failed to connect to password protected server. Check that password is correct.

不幸的是，文档并没有说太多。

有人有将 VSCode 连接到远程服务器的经验吗？谢谢。

是否有类似findorgrep的命令可用于搜索我的 Google 存储桶？

我只能找到ls，但这并不是我所需要的。我想搜索包含特定字符串或匹配特定正则表达式的特定文件夹名称和文件名。

我想用与此类似的自定义颜色图绘制热图，尽管不完全相同。

我想要一个像这样的颜色图。在区间 [-0.6, 0.6] 中，颜色为浅灰色。高于 0.6，红色变深。低于 -0.6 的另一种颜色，比如蓝色，会增强。

如何使用 python 和 matplotlib 创建这样的颜色图？

到目前为止我所拥有的：在seaborn那里有一个命令seaborn.diverging_palette(220, 10, as_cmap=True)，它可以产生一个从蓝-光-灰-红开始的颜色图。但是仍然与 [-0.6, 0.6] 没有差距。

这个库有 Python 等价物吗？

https://github.com/r-lib/这里/

我想以天、小时、分钟和秒为单位测量一段代码的执行时间。这是我到目前为止所拥有的：

import time
start_time = time.time()

# some code

elapsed = time.strftime("%H:%M:%S", time.gmtime(time.time() - start_time))
print(f"Took: {elapsed}")

问题是，如果我测量的代码花费的时间超过 24 小时，则显示的时间会溢出并再次从零开始。我想要这样的东西：

# Example: 12 hours and 34 minutes should be printed as 
> Took: 12:34:00

# Example: 26 hours and 3 minutes should be printed as 
> Took: 1:02:03:00

我有一长串 .zarr 数组，我想将它们合并到一个数组中并写入磁盘。

我的代码大致如下：

import dask.array
import zarr
import os

local_paths = ['parts/X_00000000.zarr',
 'parts/X_00000001.zarr',
 'parts/X_00000002.zarr',
 'parts/X_00000003.zarr',
 'parts/X_00000004.zarr',
 'parts/X_00000005.zarr',
 ...]

result_path = "testtest"
os.makedirs(result_path)

Xs = [dask.array.from_zarr(zarr.DirectoryStore(p)) for p in local_paths]
X = dask.array.concatenate(Xs, axis=0)
X = X.rechunk({0: 10000, 1:-1, 2:-1, 3:-1})
dask.array.to_zarr(X, zarr.DirectoryStore(result_path))

来自的每个数组都local_paths包含一个 64x64 图像列表。这些列表的长度各不相同。所以第一个的形状可能是(100, 64, 64, 3)，第二个的形状可能是(200, 64, 64, 3)。

执行此代码的最后一行，导致我的内存完全消耗，然后 Jupyter 笔记本完全崩溃（没有给我错误消息或异常）。

为了调查问题，我打印了任务图，因此用以下两行替换了最后一行：

k = dask.array.to_zarr(X, zarr.DirectoryStore(result_path), compute=False)
k.visualize()

它非常大（链接），所以我只截取了其中两个有趣的部分：

这种结构一直重复。Dask 获取连接的输出，重新分配数据，然后尝试存储它。请注意作为重叠过渡结果的粗黑条。

现在看看这些转换来自哪里：

查看create中间的节点。我假设这是图中创建 zarr DirectoryStore 的部分。 …