小编Jon*_*han的帖子

我试图了解 Dask 在本地计算机上的使用模式。

具体来说，

• 我有一个适合内存的数据集
• 我想做一些熊猫操作
  • 通过...分组...
  • 日期解析
  • ETC。

Pandas 通过单个核心执行这些操作，这些操作对我来说需要几个小时。我的机器上有 8 个核心，因此，我想使用 Dask 尽可能地并行化这些操作。

我的问题如下： Dask 中执行此操作的两种方式有什么区别：

import pandas as pd
from sklearn.datasets import load_iris

iris = load_iris()

(1)

import dask.dataframe as dd

df = dd.from_pandas(
    pd.DataFrame(iris.data, columns=iris.feature_names),
    npartitions=2
)

df.mean().compute()

(2)

import dask.dataframe as dd
from distributed import Client

client = Client()

df = client.persist(
    dd.from_pandas(
        pd.DataFrame(iris.data, columns=iris.feature_names),
        npartitions=2
    )
)

df.mean().compute()

一种使用模式相对于另一种使用模式有什么好处？为什么我应该使用其中一种而不是另一种？

我有一个相关矩阵，但指定为对，例如：

cm = pd.DataFrame({'name1': ['A', 'A', 'B'], 
                   'name2': ['B', 'C', 'C'], 
                   'corr': [0.1, 0.2, 0.3]})
cm
    name1   name2   corr
0   A       B       0.1
1   A       C       0.2
2   B       C       0.3

将它变成一个 numpy 二维数组相关矩阵的最简单方法是什么？

    A   B   C
A 1.0 0.1 0.2
B 0.1 1.0 0.3
C 0.2 0.3 1.0

我有一个类似于的堆叠工作流程

import numpy as np
from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import StackingClassifier
from sklearn.pipeline import make_pipeline
import xgboost as xgb

X = np.random.random(size=(1000, 5))
y = np.random.choice([0,1], 1000)
w = np.random.random(size=(1000,))

scaler = StandardScaler()
log_reg = LogisticRegression()

params = {
    'n_estimators': 10,
    'max_depth': 3,
    'learning_rate': 0.1
}

log_reg_pipe = make_pipeline(
    scaler,
    log_reg
)

stack_pipe = make_pipeline(
    StackingClassifier(
        estimators=[('lr', lr_stack_pipe)],
        final_estimator=xgb.XGBClassifier(**params),
        passthrough=True,
        cv=2
    )
)

我希望能够将样本权重传递到 xgboost 中。我的问题是如何在最终估计器中设置样本权重？

我努力了

stack_pipe.fit(X, y, …