小编Att*_*k68的帖子

我想在 Scikit-Learn 中创建一个管道，其中一个特定步骤是异常值检测和删除，允许将转换后的数据传递给其他转换器和估计器。

我已经搜索过 SE，但在任何地方都找不到这个答案。这可能吗？

我有一个多索引数据帧：

import pandas as pd
import numpy as np

l0, l1 = ['A', 'B'],['a', 'b']
c0 = ['c1', 'c2', 'c3']
data = np.arange(12).reshape(4,3)
df = pd.DataFrame(data=data, 
                  index=pd.MultiIndex.from_product([l0,l1]),
                  columns=c0)

>>>
     c1  c2  c3
A a   0   1   2
  b   3   4   5
B a   6   7   8
  b   9  10  11

我想转置 MultiIndex 和列的级别，以便得到：

df2 = pd.DataFrame(index=pd.MultiIndex.from_product([l0, c0]),
                   columns=l1)

>>>
    a    b
A c1  NaN  NaN
  c2  NaN  NaN
  c3  NaN  NaN
B c1  NaN  NaN
  c2  NaN  NaN
  c3  NaN …

我有一个用 Flask 和 Flask-Login 构建的网站，所以我知道它会在某个时候生成 cookie。但我的问题比这更基本。

Flask 应用程序是否总是立即生成 cookie？

如果没有，是否有任何工具可以让我确定我的应用程序的哪个部分在哪个时间点生成了 cookie，例如是否可以在操作网站时监控 Chrome 开发工具？

这个问题的上下文是 GDPR 合规性，特别是尝试在开始时请求许可（最初没有创建 cookie！）然后当用户点击接受时有一个过程，这意味着用户（匿名或其他）不会看到该许可再次请求横幅（直到本地浏览器缓存清除）

我有一个数据库升级迁移，我想应用于数据库列：

def upgrade():
    # ### commands auto generated by Alembic - please adjust! ###
    with op.batch_alter_table('details') as batch_op:
        batch_op.alter_column('details', 'non_essential_cookies',
                              existing_type=sa.BOOLEAN(),
                              nullable=False)
    # ### end Alembic commands ###

我正在实施批处理模式，因为不支持 ALTER，并且之前我收到了此错误：sqlalchemy.exc.OperationalError: (sqlite3.OperationalError) near "ALTER":。但是，我希望批处理模式能够工作，但现在我收到了新的错误：

TypeError: <flask_script.commands.Command object at 0x1149bb278>: alter_column() got multiple values for argument 'nullable'.

我的表中只有一个元组，并且相关属性不为 NULL，因此数据库迁移是有效的。我只是不明白为什么有多个值

我有以下张量执行，

np.einsum('k,pjqk,yzjqk,yzk,ipqt->it', A, B, C, D, E)

我注意到，当“z”或“q”维度扩展时，执行时间确实受到了影响，尽管我的直觉是它可能不应该那么糟糕 - 也许这是我的输入形式，我可以通过手动张量收缩来优化。

经过一番挖掘后，我发现优化有两种模式：“最优”和“贪婪”。如果我根据两种模式评估我的路径，我分别有：

(['einsum_path', (0, 3), (1, 3), (0, 2), (0, 1)],
'  Complete contraction:  k,pjqk,yzjqk,yzk,ipqt->it\n'
'         Naive scaling:  8\n'
'     Optimized scaling:  5\n'
'      Naive FLOP count:  5.530e+04\n'
'  Optimized FLOP count:  7.930e+02\n'
'   Theoretical speedup:  69.730\n'
'  Largest intermediate:  2.400e+01 elements\n'
'--------------------------------------------------------------------------\n'
'scaling                  current                                remaining\n'
'--------------------------------------------------------------------------\n'
'   3                  yzk,k->yzk                  pjqk,yzjqk,ipqt,yzk->it\n'
'   5              yzk,yzjqk->jqk                        pjqk,ipqt,jqk->it\n'
'   4                jqk,pjqk->qp                              ipqt,qp->it\n'
'   4                 qp,ipqt->it                                   it->it')

和

(['einsum_path', (2, 3), (1, 3), (1, 2), …

我有一个 20GB、100k x 100k 'float16' 2D 数组作为数据文件。我将其加载到内存中，如下所示：

fp_read = np.memmap(filename, dtype='float16', mode='r', shape=(100000, 100000))\n

然后我尝试从中读取切片。我需要采取的垂直切片实际上是随机的，但性能非常差，或者我做错了什么？

分析：

我与其他形式的横截面切片进行了比较，尽管我不知道为什么应该这样，但它要好得多：

%timeit fp_read[:,17000:17005]    # slice 5 consecutive cols\n1.64 \xc2\xb5s \xc2\xb1 16.4 ns per loop (mean \xc2\xb1 std. dev. of 7 runs, 1000000 loops each)\n\n%timeit fp_read[:,11000:11050:10]\n1.67 \xc2\xb5s \xc2\xb1 21 ns per loop (mean \xc2\xb1 std. dev. of 7 runs, 1000000 loops each)\n\n%timeit fp_read[:,5000:6000:200]\n1.66 \xc2\xb5s \xc2\xb1 27.3 ns per loop (mean \xc2\xb1 std. dev. of 7 runs, 1000000 loops each)\n\n%timeit …

说我有一个看起来像下面的数组：

arr = [[1, 2, 3],
       [4, 5, 6],
       [7, 8, 9]]

我还有另一个数组slicer = [1,3,2]。我想将这些值应用为沿轴1的轴0上的切片索引。

这是行不通的（并且实际上没有办法指定nd部分在ndarray中是轴1），但是假设我尝试了 arr[:slicer, :]

我希望获得

out = [[1,   2,   3],
       [nan, 5,   6],
       [nan, 8, nan]]

这是应用slice arr[:1, :]，，然后分别从第1列，第2列和第3列中进行选择arr[:3, :]，arr[:2, :]然后重新组合到上面的数组中，并删除缺失值的组合。

我想避免循环，并试图找到一种快速的矢量化解决方案

假设我有一组用户，每个用户都可以访问一组工具。相同的工具可能有许多用户具有访问权限，因此这是多对多关系：

class User(db.Model):
    __tablename__ = 'user'
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String, unique=True)
    tools = db.relationship("Tool", secondary=user_tool_assoc_table,
                            back_populates='users')

class Tool(db.Model):
    __tablename__ = 'tool'
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String, unique=False)

user_tool_assoc_table = db.Table('user_tool', db.Model.metadata,
    db.Column('user', db.Integer, db.ForeignKey('user.id')),
    db.Column('tool', db.Integer, db.ForeignKey('tool.id')))

请注意，用户名是唯一的，但工具名不是。因此，User.name:Mike1并且User.name:Mike2可以访问Tool.name:Hammer，User.name:John1并且User.name:John2可以分别访问，并且可以使用Tool.name:Hammer相同的名称访问，但是每个名称都不同Tool.ids。

我想做一个约束，即在User.tools集合中永远不能有一个与另一个同名的工具，即

• Tool如果已经存在具有该名称的用户，则用户不能创建一个新的内容作为其集合的一部分。Mike1无法创建一个称为Hammer其tools集合一部分的新工具。
• 一个Tool存在于数据库不能被追加到tools，如果一个具有相同名称的设置已经存在的用户的集合，即John1的Hammer不能与Mike1共享，因为Mike1已有自己Hammer。
• James但是， …