小编use*_*197的帖子

在以下代码中:

# Load dataset
iris = datasets.load_iris()
X, y = iris.data, iris.target

rf_feature_imp = RandomForestClassifier(100)
feat_selection = SelectFromModel(rf_feature_imp, threshold=0.5)

clf = RandomForestClassifier(5000)

model = Pipeline([
          ('fs', feat_selection), 
          ('clf', clf), 
        ])

 params = {
    'fs__threshold': [0.5, 0.3, 0.7],
    'fs__estimator__max_features': ['auto', 'sqrt', 'log2'],
    'clf__max_features': ['auto', 'sqrt', 'log2'],
 }

 gs = GridSearchCV(model, params, ...)
 gs.fit(X,y)

什么应该用于预测？

• gs？
• gs.best_estimator_？要么
• gs.best_estimator_.named_steps['clf']？

这3个有什么区别？

我正在尝试设计一个模块化的实时监控系统,因此可以为不同的硬件和网络进行分布,扩展/重新配置.

我很快得出结论,我需要某种分布式企业消息系统.但是有很多选择,每个选项都有优点和缺点,其中一些选项决定了不同的架构.我正在努力弄清楚我是否需​​要经纪人或无代理系统,我是否需要某些系统的消息可靠性(例如RabbitMQ)或者像ZeroMQ这样的系统的轻量级高吞吐量,或者"按顺序到达"卡夫卡的高吞吐量.

首先,这些架构是否有意义？

ZeroMQ类型"Brokerless"系统:

笔记:

每个"B部分"可以有许多"A部分",许多"B部分"进入"C部分"

好处:

• 高吞吐量,低出租率
• 轻松集成到组件中,轻量级部署(无需部署代理).

缺点

• 邮件无法保证送达.有些可能会掉线.这可能是橙色突出显示区域中的问题.它对GUI来说并不重要,但如果本地控制模块正在做决定,它可能需要所有信息.(考虑到这一点,只是最新的可能就足够了 - 没有必要用过时的数据做出决定).同样,如果A和B之间的网络出现故障,则历史记录将具有不完整的历史记录.这有多重要啊？
• 没有"发现".需要更多地管理组件之间的关系.

RabbitMQ类型Broker系统:

好处:

• 邮件保证交付.
• 发现通过经纪人管理.

缺点

• 慢得多,高延迟
• 更多部署和维护(经纪人/ RabbitMQ需要在机器上安装,它不仅仅是内置于模块中)

  ---

中间选项:

我看过卡夫卡.这是经纪人,因此发现得到了解决.然而,它似乎比RabbitMQ更轻量级,虽然它不保证交付(因此更快/更低的延迟)它确实维持秩序,RabbitMQ没有.它还可以缓冲消息 - 因此,如果出现网络问题,可以检索它们.

写下来之后,我不确定保证交付的重要性.如果控制模块收到消息,如果它是"旧"则无关紧要.如果历史学家有完整的历史,那将是伟大的 - 但它是否必不可少？

在ZeroMQ中实现我自己的"消息缓冲区"可能是一种选择,用于在发生故障时存储消息的网络通信.我有比RabbitMQ更多的控制权,并且可以在我需要它时通过更不可靠(通过网络)进行消息传递时实现它.

显然,权衡这些优点或缺点是我的工作.我的问题是:还有什么需要考虑的吗？并且确实为这两个选项的结构是否合理？

我计划将大多数实现都放在C#中,而且我目前在消息传递系统方面没有经验.

我只能找到旧的C++源代码示例.无论如何,我做了我的,基于他们.这是我在python中的发布者:

import zmq
context = zmq.Context()
socket = context.socket(zmq.PUB)
socket.bind("tcp://*:5563")

while True:
    msg = "hello"
    socket.send_string(msg)
    print("sent "+ msg)
    sleep(5)

这是C++中的订阅者:

void * ctx = zmq_ctx_new();
void * subscriber = zmq_socket(ctx, ZMQ_SUB);
// zmq_connect(subscriber, "tcp://*:5563");
   zmq_connect(subscriber, "tcp://localhost:5563");
// zmq_setsockopt(subscriber, ZMQ_SUBSCRIBE, "", sizeof(""));

while (true) {
    zmq_msg_t msg;
    int rc;

    rc = zmq_msg_init( & msg);
    assert(rc == 0);
    std::cout << "waiting for message..." << std::endl;
    rc = zmq_msg_recv( & msg, subscriber, 0);
    assert(rc == 1);

    std::cout << "received: " << (char …

我试图在Python(Windows Server 2012)中实现多处理,并且无法实现我期望的性能提升程度.特别是,对于几乎完全独立的一组任务,我希望通过额外的内核进行线性改进.

我理解 - 尤其是在Windows上 - 开启新流程涉及开销[1],底层代码的许多怪癖可能会妨碍干净的趋势.但理论上,对于完全并行化的任务,趋势最终仍应接近线性[2] ; 如果我正在处理部分连续任务[3],或者可能是后勤.

但是,当我在主要检查测试函数(下面的代码)上运行multiprocessing.Pool N_cores=36时,在我进入预期性能之前,我得到了一个近乎完美的平方根关系(我服务器上的物理核心数)额外的逻辑核心.

这是我的性能测试结果图:
_{(" 归一化性能 "是[具有1个 CPU核心的运行时间]除以[具有N个 CPU核心的运行时间]).}

通过多重处理使收益大幅减少是否正常？或者我错过了实施的内容？

import numpy as np
from multiprocessing import Pool, cpu_count, Manager
import math as m
from functools import partial
from time import time

def check_prime(num):

    #Assert positive integer value
    if num!=m.floor(num) or num<1:
        print("Input must be a positive integer")
        return None

    #Check …

我在Whiskey Lake i7-8565U 上分析性能计数器和复制 512 KiB 数据（比 L2 缓存大小大两倍）的时间，并在 L2 硬件预取器的工作方面遇到了一些误解。

在Intel Manual Vol.4 MSR 中，MSR0x1A4的位 0 用于控制 L2 HW 预取器（1 表示禁用）。

考虑以下基准：

memcopy.h：

void *avx_memcpy_forward_lsls(void *restrict, const void *restrict, size_t);

memcopy.S：

avx_memcpy_forward_lsls:
    shr rdx, 0x3
    xor rcx, rcx
avx_memcpy_forward_loop_lsls:
    vmovdqa ymm0, [rsi + 8*rcx]
    vmovdqa [rdi + rcx*8], ymm0
    vmovdqa ymm1, [rsi + 8*rcx + 0x20]
    vmovdqa [rdi + rcx*8 + 0x20], ymm1
    add rcx, 0x08
    cmp rdx, rcx
    ja avx_memcpy_forward_loop_lsls …

我正在处理相当大的 Pandas DataFrame - 我的数据集类似于以下df设置：

import pandas as pd
import numpy  as np

#--------------------------------------------- SIZING PARAMETERS :
R1 =                    20        # .repeat( repeats = R1 )
R2 =                    10        # .repeat( repeats = R2 )
R3 =                541680        # .repeat( repeats = [ R3, R4 ] )
R4 =                576720        # .repeat( repeats = [ R3, R4 ] )
T  =                 55920        # .tile( , T)
A1 = np.arange( 0, 2708400, 100 ) # ~ 20x re-used
A2 …

我有一个客户端,其代码我无法更改 - 但我想(重新)使用ZeroMQ套接字编写.

客户端使用TCP原始UDP套接字和原始套接字.

我知道我可以ZMQ_ROUTER_RAW用于原始TCP套接字,但原始UDP数据流呢？

在下面的例子中(理想化的"游戏")有两个线程.更新数据并将RenderThread其"呈现"到屏幕的主线程.我需要的是那两个要同步的东西.我没有能力运行几次更新迭代而不为它们中的每一个运行渲染.

我使用a condition_variable来同步这两个,所以理想情况下,更快的线程将花费一些时间等待更慢.但是,如果其中一个线程在很短的时间内完成迭代,则条件变量似乎不起作用.它似乎很快就会重新获取互斥锁的锁定,然后wait另一个线程才能获取它.即使notify_one被称为

#include <iostream>
#include <thread>
#include <chrono>
#include <atomic>
#include <functional>
#include <mutex>
#include <condition_variable>

using namespace std;

bool isMultiThreaded = true;

struct RenderThread
{
    RenderThread()
    {
        end = false;
        drawing = false;
        readyToDraw = false;
    }

    void Run()
    {
        while (!end)
        {
            DoJob();
        }
    }

    void DoJob()
    {
        unique_lock<mutex> lk(renderReadyMutex);
        renderReady.wait(lk, [this](){ return readyToDraw; });
        drawing = true;

        // RENDER DATA
        this_thread::sleep_for(chrono::milliseconds(15)); // simulated render time
        cout << "frame " …

我们看到ZeroMQ上有一个奇怪且无法解释的现象,Windows 7通过TCP发送消息._{(或者inproc,因为ZeroMQ在Windows内部使用TCP进行信令).}

这种现象是前500条消息越来越慢,延迟越来越慢.然后,除了由CPU /网络争用引起的峰值之外,延迟下降和消息一直快速到达.

这里描述了这个问题:https://github.com/zeromq/libzmq/issues/1608

它始终是500条消息.如果我们发送没有延迟,那么消息被批处理,所以我们看到这个现象延伸了几千个发送.如果我们在发送之间延迟,我们会更清楚地看到图表.即使在发送之间延迟多达50-100毫秒也不会改变事情.

邮件大小也无关紧要.我已经测试了10字节消息和10K消息,结果相同.

最大延迟始终为2毫秒(2,000 usec).

在Linux机器上,我们没有看到这种现象.

我们想要做的是消除这个初始曲线,因此消息与正常的低延迟(大约20-100 usec)保持新的连接.

更新:该问题不会在Windows 10和8上显示.它似乎只发生在Windows 7上.

我试图安装CL-jupyter(成为共口齿不清内核Jupyter),我不能让它工作:当我打开一个新的口齿不清的笔记本电脑(或更改现有的笔记本电脑的内核),它显示后崩溃以下消息:

[I 18:26:50.855 NotebookApp] Kernel started: ccba815a-9065-4fad-9d95-06f6291136d2
To load "cl-jupyter":
  Load 1 ASDF system:
    cl-jupyter
; Loading "cl-jupyter"
...............

cl-jupyter: an enhanced interactive Common Lisp REPL
(Version 0.7 - Jupyter protocol v.5.0)
--> (C) 2014-2015 Frederic Peschanski (cf. LICENSE)

kernel configuration = ((hb_port . 58864) (shell_port . 37462)
                        (transport . tcp) (iopub_port . 43232)
                        (signature_scheme . hmac-sha256)     (control_port . 52184)
                        (stdin_port . 45879)
                        (key . 2ae7d65f-65f9-40d8-bfd4-21760eaec0ca)
                        (ip . 127.0.0.1))
[Hearbeat] starting...
[Heartbeat] thread started
[Heartbeat] thread …