小编use*_*878的帖子

我需要编写一个程序,其中频繁地评估字符串表达式.表达式的示例如下:

"x0*a0*a0+x1*a1+x2*a2+x3*a3+x4*a4....."

表达式可以很长,字符串可以包含多个这样的表达式.

我使用C++库exprtk编写了一些测试代码.

vector<std::string> observation_functions;
vector<std::string> string_indices;


template<typename T>
float* get_observation(float* sing_j, float* zrlist, int num_functions,int num_variables)
{
    //omp_set_nested(1);

    float* results = (float*)malloc(sizeof(float)*num_functions);
    exprtk::symbol_table<float> symbol_table;

    exprtk::expression<T> expression;
    exprtk::parser<T> parser;
    int i;
    for( i = 0; i < num_variables; i++)
    {
            symbol_table.add_variable("x"+string_indices[i], sing_j[i]);
            symbol_table.add_variable("a"+string_indices[i], zrlist[i]);
    }

    expression.register_symbol_table(symbol_table);
    for(i = 0; i < num_functions; i++)
    {
            parser.compile(observation_functions[i],expression);
            results[i] = expression.value();
    }
    return results;
}



int main()
{

    for( int i = 0; i < 52; i++)
    {

    ostringstream s2;
    s2<<i;
    string_indices.push_back(s2.str()); …

我试图计算numpy数组中包含的多个时间序列之间的成对距离.请参阅下面的代码

print(type(sales))
print(sales.shape)

<class 'numpy.ndarray'>
(687, 157)

因此,sales包含长度为157的687个时间序列.使用pdist计算时间序列之间的DTW距离.

import fastdtw
import scipy.spatial.distance as sd

def my_fastdtw(sales1, sales2):
    return fastdtw.fastdtw(sales1,sales2)[0]

distance_matrix = sd.pdist(sales, my_fastdtw)

---编辑:尝试没有pdist()-----

distance_matrix = []
m = len(sales)    
for i in range(0, m - 1):
    for j in range(i + 1, m):
        distance_matrix.append(fastdtw.fastdtw(sales[i], sales[j]))

---编辑:并行化内循环-----

from joblib import Parallel, delayed
import multiprocessing
import fastdtw

num_cores = multiprocessing.cpu_count() - 1
N = 687

def my_fastdtw(sales1, sales2):
    return fastdtw.fastdtw(sales1,sales2)[0]

results = [[] for i in range(N)] …

在阅读zeromq指南时,我遇到了客户端代码,它在循环中发送100k请求,然后在第二个循环中接收回复.

#include "../include/mdp.h"
#include <time.h>


int main (int argc, char *argv [])
{
    int verbose = (argc > 1 && streq (argv [1], "-v"));
    mdp_client_t *session = mdp_client_new ("tcp://localhost:5555", verbose);
    int count;
    for (count = 0; count < 100000; count++) {
        zmsg_t *request = zmsg_new ();
        zmsg_pushstr (request, "Hello world");
        mdp_client_send (session, "echo", &request);
    }
    printf("sent all\n");

    for (count = 0; count < 100000; count++) {
        zmsg_t *reply = mdp_client_recv (session,NULL,NULL);
        if (reply)
            zmsg_destroy (&reply);
        else
            break;              //  Interrupted by …

我在MacPro上运行带有Ubuntu 14.04的VM Fusion 8 Pro.MacPro配备双AMD FirePro D500 GPU.我在Ubuntu中安装了AMD APP SDK,但它只是将CPU视为设备,而不是GPU.有人可以指导我,以便我可以在GPU上运行OpenCL内核.

谷歌搜索已经揭示了诸如GPU直通之类的东西,但是关于如何从VMWare Fusion中精确访问GPU的细节还不够.

此致

维沙尔

目前,我正在使用JSON库来序列化发送方(JeroMQ)上的数据,并在接收方(C,ZMQ)进行反序列化.但是,在解析时,JSON库开始消耗大量内存,操作系统会终止进程.所以,我想按原样发送float数组,即不使用JSON.

现有的发件人代码在下面(syn0并且syn1是Double数组).如果syn0并且syn1每个大约100 MB,则在解析接收到的数组时,该进程将被终止,即下面的代码段的最后一行:

import org.zeromq.ZMQ
import com.codahale.jerkson
socket.connect("tcp://localhost:5556")

socket.send(json.JSONObject(Map("syn0"->json.JSONArray(List.fromArray(syn0Global)))).toString())
println("SYN0 Request sent”)
val reply_syn0 = socket.recv(0)
println("Response received after syn0: " + new String(reply_syn0))
logInfo("Sending Syn1 request … , size : " + syn1Global.length )

socket.send(json.JSONObject(Map("syn1"->json.JSONArray(List.fromArray(syn1Global)))).toString())
println("SYN1 Request sent")
val reply_syn1 = socket.recv(0)

socket.send(json.JSONObject(Map("foldComplete"->"Done")).toString())
println("foldComplete sent")
//  Get the reply.
val reply_foldComplete = socket.recv(0)
val processedSynValuesJson = new String(reply_foldComplete)
val processedSynValues_jerkson =   jerkson.Json.parse[Map[String,List[Double]]](processedSynValuesJson)

可以在不使用JSON的情况下传输这些数组吗？

这里我在两个C程序之间传输一个float数组:

//client.c
int main (void)
{ …

我正在使用提供的季节性分解分解多个时间序列。这statsmodels是代码和相应的输出：

def seasonal_decompose(item_index):
    tmp = df2.loc[df2.item_id_copy == item_ids[item_index], "sales_quantity"]
    res = sm.tsa.seasonal_decompose(tmp)
    res.plot()
    plt.show()

seasonal_decompose(100)

有人可以告诉我如何以X列的行格式绘制多个此类图，以查看多个时间序列的行为吗？

下面是一个opencl内核,它为多个独立矩阵执行阻塞矩阵乘法.selectMatrixA和selectMatrixB以行主要顺序存储多个矩阵(相同大小和方形矩阵).

// Matrix multiplication: C = A * B.


#define BLOCK_SIZE 20
#define MATRIX_SIZE 100 * 100

#define BLOCK_DIMX 5 // Number of blocks in the x dimension

__kernel void
batchedMatrixMul(__global float *selectMatrixC, __global float *selectMatrixA, __global   
float *selectMatrixB, int wA, int wB)
{
    // Block index
    int bx = get_group_id(0);
    int by = get_group_id(1);


    __global float *C = selectMatrixC + (bx/BLOCK_DIMX) * MATRIX_SIZE;
    __global float *A = selectMatrixA + (bx/BLOCK_DIMX) * MATRIX_SIZE;
    __global float *B = selectMatrixB + (bx/BLOCK_DIMX) …

我正在测试majordomo经纪人的吞吐量.随github上的majordomo代码附带的test_client.c发送同步请求.我想测试majordomo代理可以实现的最大吞吐量.规范(http://rfc.zeromq.org/spec:7)表示它每秒可以切换多达一百万条消息.

首先,我更改了客户端代码以异步发送100k请求.即使在所有套接字上的HWM设置得足够高并且将TCP缓冲区增加到4 MB之后,我也会观察到三个并行运行的客户端丢包.

所以我改变了客户端一次发送10k个请求,然后为它收到的每个回复发送两个请求.我选择10k是因为这允许我并行运行多达十个客户端(每个发送100k消息)而不会丢失任何数据包.这是客户端代码:

#include "../include/mdp.h"
#include <time.h>
int main (int argc, char *argv [])
{
    int verbose = (argc > 1 && streq (argv [1], "-v"));
    mdp_client_t *session = mdp_client_new (argv[1], verbose);
    int count1, count2;
    struct timeval start,end;
    gettimeofday(&start, NULL);
    for (count1 = 0; count1 < 10000; count1++) {
        zmsg_t *request = zmsg_new ();
        zmsg_pushstr (request, "Hello world");
        mdp_client_send (session, "echo", &request);
    }
    for (count1 = 0; count1 < 45000; count1++) {
        zmsg_t *reply = mdp_client_recv (session,NULL,NULL); …

我遇到了getNative API,通过它来调用来自Hyperledger作曲家的链码.见这里:https://github.com/hyperledger/composer/issues/3120

有人可以告诉我这究竟是如何工作的？假如我有一个带有getter和setter的非常简单的链代码,我可以从作曲家的JS代码中调用它们

我是 Nodejs 新手，决定pino在我的应用程序中使用记录器。这是显示我如何使用它的代码片段：

const expressPino = require('express-pino-logger');
const { LOGLEVEL } = require('../config.js');

// Constructs a Pino Instance
const logger = pino({
  level: LOGLEVEL || 'trace',
  prettyPrint: { levelFirst: true, colorize: true, ignore: 'pid' },
});
// Construct an express middleware using the above pino instance
const expressLogger = expressPino({ logger });

module.exports = { logger, expressLogger };

现在，每次我这样做时req.log.debug(config['abc'])，整个请求正文都会被记录下来，从而使日志阅读起来非常麻烦。对于每个这样的log语句，输出如下所示：

DEBUG [1610445271782] (on blserver-org1): sku=FIN01  Query String
req: {
  "id": 1,
  "method": "POST",
  "url": "/ifo_params?sku=FIN01", …