小编Bra*_*rad的帖子

假设我有一个MultiIndex DataFrame:

                                c       o       l       u
major       timestamp                       
ONE         2019-01-22 18:12:00 0.00008 0.00008 0.00008 0.00008 
            2019-01-22 18:13:00 0.00008 0.00008 0.00008 0.00008 
            2019-01-22 18:14:00 0.00008 0.00008 0.00008 0.00008 
            2019-01-22 18:15:00 0.00008 0.00008 0.00008 0.00008 
            2019-01-22 18:16:00 0.00008 0.00008 0.00008 0.00008

TWO         2019-01-22 18:12:00 0.00008 0.00008 0.00008 0.00008 
            2019-01-22 18:13:00 0.00008 0.00008 0.00008 0.00008 
            2019-01-22 18:14:00 0.00008 0.00008 0.00008 0.00008 
            2019-01-22 18:15:00 0.00008 0.00008 0.00008 0.00008 
            2019-01-22 18:16:00 0.00008 0.00008 0.00008 0.00008

我希望从这个DataFrame生成一个带有3维的NumPy数组,假设数据框在主列中有15个类别,4列和一个长度为5的时间索引.我想创建一个形状为(的numpy数组)4,15,5)分别表示(columns,categories,time_index).

应该创建一个数组:

array([[[8.e-05, 8.e-05, …

我正在尝试实现一个汇总表，该表将来自多个不同表的数据整理到一个表中，以进行特征工程，预处理和规范化。我面临许多问题，第一个问题是我必须以某种方式构造此聚合表的架构而无需对其进行硬编码，这使我在添加其他数据源方面具有足够的灵活性。

trades
  - exch1
    - sym1
    - sym2
  - exch2
    - sym1
    - sym2
book
  - exch1
    - sym1
    - sym2
  - exch2
    - sym1
    - sym2
sentiment
   - sym1
   - sym2

正如我在前面的问题中已经指出的那样，当我想在kdb-tick体系结构中的聚合表中（在聚合之后）插入可能具有或没有其他模式的新聚合时，就会出现问题。

我已经注意到该uj操作似乎是一种适当的操作，好像输出速率将仅约为0.5-1赫兹，但是我被告知，由于它可能会引起反事实，因此可以将其视为反模式。持久性问题，不是有效的操作等。

我已经考虑过在执行插入/向上插入操作之前检查架构（如果架构不同，请更新架构，然后插入）。但是，这也可能效率不高。

我已经注意到了对先前问题的回答，但是似乎所有的消极观点都可能超过其积极方面。

聚合的性质意味着，我仅需要RTE订户/工作人员上大约1000行的表即可有效运行聚合，从而将较旧的记录清除到磁盘上。但是，列数可能会间歇性变化（添加了新的提要等），不一定在一天之内。

数据的性质还意味着聚合需要连续运行，即将数据分割成几天是无效的。

我还考虑过为每个新功能维护一个单独的表，但是表的数量也会导致效率低下。

当人们选择尝试将旧的/清除的聚合行发送给工作人员，然后定期保留这些聚合时，还会出现问题。如何修改kdb-tick发布者-订阅者体系结构以支持.u.upd[]聚合数据的列何时可能更改？问题不在于kdb-tick架构本身，而是如何在保持向后架构兼容性/效率的同时对其中的数据进行聚合？

我什至曾考虑在Rust中创建自己的特定于域的数据库，将数据划分为分片的平面文件。但是由于我能够进行/创建的高级查询操作，选择坚持使用kdb / q。

我认为，在线/实时运行这样的聚合对于将kdb +与ml结合使用而言是一项重要功能，但是我还找不到任何文档。

因此，我的问题可以总结如下：规范的实现是什么？如上kdb所述，如何有效地聚合来自多个源的数据？非常感谢您的建议。

我正在尝试确定如何创建一个列来预先指示（X行）何时另一列值的下一次出现将与熊猫一起发生，而熊猫实际上执行以下功能（在这种情况下，X = 3）：

df

rowid  event   indicator
1      True    1 # Event occurs
2      False   0
3      False   0
4      False   1 # Starts indicator
5      False   1
6      True    1 # Event occurs
7      False   0

除了对每一行进行迭代/递归循环外：

i = df.index[df['event']==True]
dfx = [df.index[z-X:z] for z in i]
df['indicator'][dfx]=1
df['indicator'].fillna(0)

但是，这似乎效率低下，是否有更简洁的方法来实现上述示例？谢谢

我试图确定如何创建一个“向下计数”的列，直到使用熊猫本质上执行以下功能的另一列中的下一个值出现为止：

rowid  event   countdown
1      False   0 # resets countdown
2      True    2 # resets countdown
3      False   1
4      False   0
5      True    1 # resets countdown
6      False   0
7      True    1 # resets countdown
...

其中，事件列定义了列中的事件是否发生（真）（假）。并且倒数列标识在所述事件发生之前必须发生的后续行/步骤的数量。以下内容适用于何时需要“计数”事件发生的时间：

df.groupby(df.event.cumsum()).cumcount()
Out[46]: 
0    0
1    0
2    1
3    2
4    0
5    1
dtype: int64

但是，这有效地实现了我想要完成的任务的逆，是否有一种实现上述示例的简洁方法，谢谢！

考虑到强化学习环境,Tensorflow代理将在每个观察到的环境中采取"步骤".

如何最有效地容纳对可变长度的观察,例如当观察超过1024个占位符限制(即10000个字符长的维基百科文章)时,注意占位符是不可变的并且在计算期间不能动态地改变:

self.obs = tf.placeholder(tf.float32, shape=(None,1024), name='obs')

我熟悉填充方法,其中指定了最大行长度,并且使用占位符填充未占用的字符.但是,当处理100个字符和10000个字符之间不同长度的输入时,此方法似乎无效,因此(None, 10000)当使用9900占位符字符和大量昂贵的金额处理有效长度仅为100个字符的输入时,占位符的形状必须均匀记忆和计算实际上是无用的,在强化学习环境中更加复杂,因此正在采取数百万步骤来学习有效的政策.

我知道嵌入方法这个词.

然而,这种方法存在许多问题,包括但不限于:缺乏细节和扩展性能,缺乏标点符号理解以及其他字符和逻辑表示,如数学公式所示.

如何有效地构建输入流,从而可以通过Tensorflow代理以避免上述问题的方式有效地消耗变化的输入大小？

我试图创建一个索引循环FIFO(先进先出)缓冲区,用于保存烛台图表的最后90分钟,该图表用于按分钟汇总的pandas数据帧中的一组15个资产(即window_size = 150)实时显示在客户端应用程序(蜡烛棒图).它将分别为每个(1m)时间步长的每个资产维持近,开,高,低和音量特征.各个烛台将由websocket更新,其中最新的时间间隔将根据价格(烛台)变化进行更新.在pandas中表示此数据结构的最有效机制是什么,客户端应用程序需要输出形状[5,15,90],如as_frame中所示,表示[close,open,high,low,volume] 15个资产和90个间隔.

因此数据将表示为:

assets  time   close    open    high    low    volume
asset1  time1  0.001    0.002   0.003   0.001  0.001
        time2  0.001    0.001   0.003   0.001  0.001
        ...
        time90 ...

...

asset15 time1  0.001    0.002   0.003   0.001  0.001
        time2  0.001    0.001   0.003   0.001  0.001
        ...
        time90 ...

我用python pandas实现了一个天真的解决方案:

class Buffer():
    def __init__(self):
        self.cols = [
                'asset',
                'timestamp',
                'close',
                'high',
                'low'
        ];

        self.lvls = [
            'asset',
            'timestamp'
        ]

        self.frame = pd.DataFrame(
            columns=self.cols
        );

        self.frame.set_index(self.lvls)

    def add(
        self,
        entry
    ):
        ... what would …

我正在尝试使用qpython从python客户端实现多行查询。

我想执行以下查询：

a = """
/declare a function that pivots a table on index
piv:{[t;k;p;v]f:{[v;P]`${raze "_" sv x} each string raze P,'/:v};v:(),v; k:(),k; p:(),p;G:group flip k!(t:.Q.v t)k;F:group flip p!t p;key[G]!flip(C:f[v]P:flip value flip key F)!raze{[i;j;k;x;y]a:count[x]#x 0N;a[y]:x y;b:count[x]#0b;b[y]:1b;c:a i;c[k]:first'[a[j]@'where'[b j]];c}[I[;0];I J;J:where 1<>count'[I:value G]]/:\:[t v;value F]};

/get aggregated trades table 
tt:0!select last_price:last price, last_qty: last qty, low_qty: min qty by exch,sym,side,1 xbar time.second from trades

/apply pivot function on aggregated trade table
piv[`tt;`second;`exch`sym`side;`last_price`last_qty`low_qty]
"""

以下qpython客户端仅调用远程kdb + / q服务器即可检索对上述查询的响应

with qconnection.QConnection(host='localhost', port=5001, …

我正在尝试根据kdb tick架构从tick函数中对表运行迭代联合联接：

table1:([]time:`timespan$();sym:`symbol$();var1:`float$());

if[not system"t";system"t 1000";
    .z.ts:{
        table2: ...
        table1:table1 uj table2 / throws non descriptive error
        `table1 uj table2 / throws type error
    }

非描述性错误：

'table1
[0]（）

我试图维护一个本地表，该表保留最后500行左右（带有动态列），以便运行进一步的处理。但是我似乎无法从tick函数中更新表。一个人应该如何实现这一功能？谢谢

我想生成许多不同的JSON结构排列作为同一数据集的表示,最好不必硬编码实现.例如,给定以下JSON:

{"name": "smith", "occupation": "agent", "enemy": "humanity", "nemesis": "neo"}`

应该产生许多不同的排列,例如:

• 更改名称: {"name":"smith"}- > {"last_name":"smith"}
• 按顺序改变: {"name":"...","occupation":"..."} -> {"occupation":"...", "name":"..."}
• 安排改变: {"name":"...","occupation":"..."} -> "smith":{"occupation":"..."}
• 模板更改: {"name":"...","occupation":"..."} -> "status": 200, "data":{"name":"...","occupation":"..."}
• 等等

目前,实施情况如下:

我正在使用itertools.permutations和OrderedDict()来查看可能的键和相应的值组合以及它们返回的顺序.

key_permutations = SchemaLike(...).permutate()

all_simulacrums = []
for key_permutation in key_permutations:
   simulacrums = OrderedDict(key_permutation)
   all_simulacrums.append(simulacrums)
for x in itertools.permutations(all_simulacrums.items()):
    test_data = json.dumps(OrderedDict(p))
    print(test_data)
    assert json.loads(test_data) == data, 'Oops! {} != {}'.format(test_data, data)

当我尝试实现排列和模板的排列时,我的问题就出现了.我不知道如何最好地实现这个功能,任何建议？

如何实现位于https://beam.apache.org/documentation/pipelines/design-your-pipeline/的以下逻辑：

//merge the two PCollections with Flatten//me 
PCollectionList<String> collectionList = PCollectionList.of(aCollection).and(bCollection);
PCollection<String> mergedCollectionWithFlatten = collectionList
    .apply(Flatten.<String>pCollections());

// continue with the new merged PCollection
mergedCollectionWithFlatten.apply(...);

从而可以将多个 PCollection 组合成 apache beam python api 中的单个 PCollection？