标签: pipeline

我正在编写 ARM 汇编代码，在某些时候必须将寄存器的单个位设置为 1。这当然最好通过“寄存器--位or掩码”方法来完成。然而，根据ARM的文档，大会ORR命令（按位OR）并没有立即采取值。换句话说，您只能将一个寄存器中的值与另一个寄存器中的值进行按位或运算。仔细想想，这是有道理的，因为 ARM 指令本身是 32 位长的，因此无法将 32 位掩码塞进指令中。然而，将立即值写入寄存器只是为了正确使用它是低效的，因为它会产生写后读的危险，这会导致 CPU 停顿。一般来说，最有效的方法是什么ORR一个带有掩码的寄存器而不浪费一个寄存器来不断地将该掩码保存在内存中？ARM 有什么推荐吗？

我有高级功能

function Start-Executable {
    [CmdletBinding()]
    Param (
        [String]$Arg1,
        [String[]]$Arg2,
        [Parameter(ValueFromPipeline=$true)][String[]]$PipeValue
    )

Begin {
    # Setup code
}
Process {
    # What goes on here?
    foreach ($val in $PipeValue) {
        # Process val here
    }
}
End {
}
}

在我的设置代码中，我需要根据用户是否提供管道输入来做一些不同的事情。但是我不知道如何在 BEGIN 块中判断是否有管道输入。有什么我可以检查的吗？

我尝试的另一件事是在循环之前将设置代码放在 PROCESS 块中，$PipeValue但这不起作用，因为似乎为每个管道值调用一次 PROCESS 块，每次$PipeValue都是一个项目的数组. 那正确吗？如果为每个值重复调用 PROCESS，为什么我需要在 PROCESS 块内进行另一个循环？

更新

澄清一下，我想要做的是在 BEGIN 中创建一个进程，在 PROCESS 中输入它并在 END 中读取输出。为此，我需要设置RedirectStandardInput为$true是否有管道输入，否则不设置。

作为变通方法，我可以让用户指定一个额外的参数（如果他们弄错了，事情就不起作用），或者我可以$first_time在 BEGIN 中设置一个标志，然后在第一次调用 PROCESS 时创建进程。如果我在没有创建进程的情况下到达 END，我会在那里创建它RedirectStandardInputas $false …

我(iid)数据集中的每个样本如下所示:
x = [a_1,a_2 ... a_N,b_1,b_2 ... b_M]

我也有每个样本的标签(这是监督学习)

的一个特点是非常稀疏的(即袋的字表示),而b特征是致密的(整数,还有那些的〜45)

我正在使用scikit-learn,我想将GridSearchCV与管道一起使用.

问题:是否可以在功能类型a上使用一个CountVectorizer,在功能类型b上使用另一个CountVectorizer ？

我想要的可以被认为是:

pipeline = Pipeline([
    ('vect1', CountVectorizer()), #will work only on features [0,(N-1)]
    ('vect2', CountVectorizer()), #will work only on features [N,(N+M-1)]
    ('clf', SGDClassifier()), #will use all features to classify
])

parameters = {
    'vect1__max_df': (0.5, 0.75, 1.0),       # type a features only
    'vect1__ngram_range': ((1, 1), (1, 2)),  # type a features only
    'vect2__max_df': (0.5, 0.75, 1.0),       # type b features …

这是我的settings.py：

from scrapy.log import INFO


BOT_NAME = 'images'

SPIDER_MODULES = ['images.spiders']
NEWSPIDER_MODULE = 'images.spiders'
LOG_LEVEL = INFO

ITEM_PIPELINES = {
    "images.pipelines.WritePipeline": 800
}

DOWNLOAD_DELAY = 0.5

这是我的pipelines.py：

from scrapy import Request
from scrapy.pipelines.files import FilesPipeline


class WritePipeline(FilesPipeline):

    def get_media_requests(self, item, info):
        for url in item["file_urls"]:
            yield Request(url)

    def item_completed(self, results, item, info):
        return item

这是非常标准的，正常的东西。然而这是我的日志中的一行：

2015-06-25 18:16:41 [scrapy] INFO: Enabled item pipelines: 

So the pipeline is not enabled. What am I doing wrong here? I've used Scrapy a few times …

此代码永远不会到达最后一行，因为完成不会从 saveBlock 传播到 sendBlock。我究竟做错了什么？

var readGenerateBlock = new TransformBlock<int, int>(n =>
    {
        Console.WriteLine("Read " + n);
        Thread.Sleep(15);
        return n;
    }); 
var groupingBlock = new BatchBlock<int>(10);
var saveBlock = new TransformManyBlock<int[], int>(n =>
    {
        Console.WriteLine("Saving {0} items [{1}; {2}]", n.Count(), n.First(), n.Last());
        Thread.Sleep(150);
        return n;
    }); 
var sendBlock = new TransformBlock<int, int>(n =>
    {
        Console.WriteLine("Sending {0}", n);
        Thread.Sleep(25);
        return n;
    }, new ExecutionDataflowBlockOptions { MaxDegreeOfParallelism = 2 }); 

readGenerateBlock.LinkTo(groupingBlock, new DataflowLinkOptions { PropagateCompletion = true });
groupingBlock.LinkTo(saveBlock, new DataflowLinkOptions { PropagateCompletion …

我听说编译器非常聪明并且知道如何优化 if / else 语句。

我也听说过三进制是高性能的，因为它们通过 CPU 的指令管道更少。

根据我所听到的，让我澄清一下：

if / else 必须通过管道传递其条件并等待结果，然后才能执行结果计算。

然而，三元可以将结果的计算传递给 cpu，而无需等待布尔表达式通过管道。

那么，哪个更快，三元组还是 if / else ？

我正在比较两个关于KerasRegressor使用Scikit-Learn的程序的性能StandardScaler:一个程序与Scikit-Learn Pipeline和一个程序没有Pipeline.

计划1:

estimators = []
estimators.append(('standardise', StandardScaler()))
estimators.append(('multiLayerPerceptron', KerasRegressor(build_fn=build_nn, nb_epoch=num_epochs, batch_size=10, verbose=0)))
pipeline = Pipeline(estimators)
log = pipeline.fit(X_train, Y_train)
Y_deep = pipeline.predict(X_test)

计划2:

scale = StandardScaler()
X_train = scale.fit_transform(X_train)
X_test = scale.fit_transform(X_test)
model_np = KerasRegressor(build_fn=build_nn, nb_epoch=num_epochs, batch_size=10, verbose=0)
log = model_np.fit(X_train, Y_train)
Y_deep = model_np.predict(X_test)

我的问题是,程序1可以使R2得分为0.98(平均3次试验),而程序2只能达到R2得分为0.84(平均3次试验).有谁可以解释这两个程序之间的区别？

我试图弄清楚如何为此构建工作流sklearn.neighbors.KNeighborsRegressor，包括：

• 归一化特征
• 特征选择（20个数字特征的最佳子集，无特定总数）
• 在1到20的范围内交叉验证超参数K
• 交叉验证模型
• 使用RMSE作为误差指标

scikit-learn中有很多不同的选项，我在决定我需要的类时有点不知所措。

此外sklearn.neighbors.KNeighborsRegressor，我认为我需要：

sklearn.pipeline.Pipeline  
sklearn.preprocessing.Normalizer
sklearn.model_selection.GridSearchCV
sklearn.model_selection.cross_val_score

sklearn.feature_selection.selectKBest
OR
sklearn.feature_selection.SelectFromModel

有人可以告诉我定义此管道/工作流程的样子吗？我认为应该是这样的：

import numpy as np
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import Normalizer
from sklearn.feature_selection import SelectKBest, f_classif
from sklearn.neighbors import KNeighborsRegressor
from sklearn.model_selection import cross_val_score, GridSearchCV

# build regression pipeline
pipeline = Pipeline([('normalize', Normalizer()),
                     ('kbest', SelectKBest(f_classif)),
                     ('regressor', KNeighborsRegressor())])

# try knn__n_neighbors from 1 to 20, and feature count from 1 to len(features)
parameters = {'kbest__k':  list(range(1, X.shape[1]+1)),
              'regressor__n_neighbors': list(range(1,21))}

# …

我正在尝试在单个Bash脚本中对构建并发管道进行建模。我知道我可以使用其他工具，但是出于理解Bash的目的，我正在这样做。

并行调度作业很容易，而在最后等待所有作业很容易。但是我想通过在任务A.1和任务X之后立即触发任务A.2来使其运行更快。为了使自己更难对付，任务A.1和任务A.2中的代码是相关且顺序的，因此如果我还可以保持代码顺序的话，那就太好了。

#!/usr/bin/bash

{
    echo "Task X"
} &
DEPENDENCY=$!

{
    echo "Task A.1"
    wait "${DEPENDENCY}"
    echo "Task A.2"
} &

{
    echo "Task B.1"
    wait "${DEPENDENCY}"
    echo "Task B.2"
} &

wait

理想情况下，这是我想要的，但是它不起作用，因为子进程不能互相等待-这很有意义-但我希望我可以跨平台的方式完成这项工作。

我实际上已经在工作，但是我无法保留* .1和* .2部分的代码

如果这可以在OSX和Linux上运行，那也很好。我希望Bash专家能够参与进来，并展示一种简洁的方式来用Bash表达这一点。

我有一个具有分类和数字功能的数据集，我想在其上应用一些转换，然后是XGBClassifier。

链接到数据集：https : //www.kaggle.com/blastchar/telco-customer-churn

由于数字和分类功能的转换不同，因此我使用了sklearn_pandas及其DataFrameMapper。

要对分类特征执行一键编码，我想使用DictVectorizer。但是要使用DictVectorizer，我首先需要将数据帧转换为字典，然后尝试使用自定义转换器Dictifier进行处理。

当我运行管道时，出现错误“ builtin_function_or_method”对象是不可迭代的。有人知道什么可能导致此错误吗？

import numpy as np 
import pandas as pd 
from sklearn_pandas import DataFrameMapper
from sklearn_pandas import CategoricalImputer
from sklearn_pandas import cross_val_score
from sklearn.preprocessing import LabelEncoder
from sklearn.preprocessing import Imputer
from sklearn.preprocessing import StandardScaler
from sklearn.feature_extraction import DictVectorizer
from sklearn.pipeline import Pipeline
from sklearn.pipeline import FeatureUnion
from sklearn.base import BaseEstimator
from sklearn.base import TransformerMixin
import xgboost as xgb

# Importing the data
df = pd.read_csv('../input/WA_Fn-UseC_-Telco-Customer-Churn.csv', na_values=' ')
X, y = df.iloc[:,1:-1], df.iloc[:,-1] …