小编Ero*_*mic的帖子

我正在编写显示图像之间匹配功能的代码.目前代码运行速度相当慢.我对如何加快它有一些想法,但我对matplotlib还不是100%舒服,或者它在幕后的工作方式.

代码的基本结构是:(我要把事情留下来让它更具可读性)

from matplotlib.patches import Rectangle, Circle, Ellipse
import matplotlib.gridspec as gridspec
from matplotlib.transforms import Affine2D
from scipy.linalg import inv, sqrtm
import matplotlib.pyplot as plt
import numpy as np

• 添加列表图像.每个图像都有自己的轴:ax,并记住ax.transData

  gs = gridspec.GridSpec( nr, nc )
  for i in range(num_images):
       dm.ax_list[i] = plt.subplot(gs[i])
       dm.ax_list[i].imshow( img_list[i])
       transData_list[i] = dm.ax_list[i].transData
  

  Run Code Online (Sandbox Code Playgroud)

• 将要素表示可视化为省略号

  for i in range(num_chips):
       axi =  chips[i].axi 
       ax  =  dm.ax_list[axi]
       transData = dm.transData_list[axi]
       chip_feats = chips[i].features
       for feat in chip_feats:
           (x,y,a,c,d) = feat
           A = numpy.array( [ ( a, 0, 0 …

  Run Code Online (Sandbox Code Playgroud)

x2_Kaxs是一个Nx3 numpy列表数组,这些列表中的元素索引到另一个数组.我想最终得到这些索引元素的Nx3 numpy数组列表.

x2_Kcids = array([ ax2_cid[axs] for axs in x2_Kaxs.flat ], dtype=object)

这输出一个(N*3)x1阵列的numpy数组.大.这几乎适用于我想要的东西.我需要做的就是重塑它.

x2_Kcids.shape = x2_Kaxs.shape

这很有效.x2_Kcids成为Nump3阵列的numpy数组.完善.

除了所有列表中x2_Kaxs只有一个元素.然后它将它展平为一个Nx3整数数组,我的代码需要在管道中稍后列出一个列表.

我提出的一个解决方案是添加一个虚拟元素,然后将其弹出,但这非常难看.还有什么更好的吗？

我相信Windows,因为没有fork,多处理模块在新的Python进程中重新加载模块.

您需要在主脚本中使用此代码,否则会发生非常严重的崩溃

if __name__ == '__main__':
    from multiprocessing import freeze_support
    freeze_support()

我有一堆模块在模块级别有调试打印语句.因此,只要加载模块,就会调用print语句.

每当我并行运行某些内容时,所有这些打印语句都会被执行.

我的问题是,是否有办法查看多处理模块是否正在导入模块,如果是这样,那么这些打印语句会被静音？

我基本上看是否有类似的东西:

 import multiprocessing
 if not multiprocessing.in_parallel_process:
     print('Loaded module: ' + __name___)

到目前为止我一直无法找到它.这可能吗？

我正在寻找一种从大小为N的集合S生成许多M大小子集的有效方法.

理想情况下,我想生成所有这些,但因为我将它们用于其他计算,这变得不可行.

相反,我想生成K个不同的S子集,使得K个选择的子集最小化K个子集之间的所有成对交叉的大小的总和.

换句话说,如果我有K个子集,我采用所有这些子集的成对交集.然后我将所有这些集合的大小加在一起.我得到的数字尽可能低.

基本上,我希望这些子集彼此"远离"是可能的.我一直在想我将如何做到这一点,但我画了一个空白.

在此期间模拟它我写了这个函数

        def subset_split(full_set, M, K):
            np.random.seed(0) # repeatibility
            seen = set([])
            subset_list = []
            for kx in xrange(K):
                np.random.shuffle(full_set)
                failsafe = 0
                while True: 
                    np.random.shuffle(full_set)
                    subset = tuple(full_set[0:M])
                    if not subset in seen: 
                        seen.add(subset)
                        subset_list.append(subset)
                        break
                    failsafe += 1
                    if failsafe > 100:
                        break
            return subset_list

它只生成以前没有见过的K个随机子集.但这并不是我想要的,因为我希望那些K子集是可重复的,并且如果它们不必如此,则不会意外地接近每个子集.

我有一个文件 foo.py，它包含一个非常慢的函数，需要 8 分钟才能计算。但是，当我将文件更改为foo.pyx并使用 cython 编译它而不进行其他更改时，计算需要 5 分钟。

我的问题是：如果我跑cython foo.py而不是cython foo.pyx然后跑 gcc -shared -pthread -fPIC -fwrapv -O2 -Wall -fno-strict-aliasing -I/usr/include/python2.7 -o foo.so foo.c

当我运行时import foo，python会导入.py文件还是编译后的.so文件？pyx 真的需要在那里吗？如果存在的话，有没有办法强制它.so接管？.py

原因是我无法在不破坏其他人机器上的代码的情况下更改 foo.py 的名称，但我真的希望它对于我的测试用例来说更快。如果我可以在本地编译它而不用担心在其他地方破坏代码，那就太好了。

（我正在测试这个，但需要一段时间）

我有一些代码可以绘制一些点.我将ax.scatter替换为ax.plot,这样我就可以单独控制每个点的颜色.然而,当我进行此更改时,轴x和y范围似乎增加.

我无法确定为什么会发生这种情况.我改变的唯一一点是分散的情节.

此代码使轴太大

    ax.scatter(x, y, c=color_list, s=pts_size, marker='o', edgecolor='none')
    #ax.plot(x, y, linestyle='None', marker='o', markerfacecolor=pts_color, markersize=pts_size, markeredgewidth=0)

这段代码做对了(但是我无法控制颜色)

    #ax.scatter(x, y, c=color_list, s=pts_size, marker='o', edgecolor='none')
    ax.plot(x, y, linestyle='None', marker='o', markerfacecolor=pts_color, markersize=pts_size, markeredgewidth=0)

有没有办法可以调用散射,这样它就不会影响我当前的轴限制？

我正在为一个正在研究的项目提供几个上下文管理器.它即将发货,我遇到了一些我开始恐慌的事情.

我的印象是你不应该再加上作为上下文管理器类的__exit__方法的参数传递的异常.但是,我正在进行一些测试,看起来上下文管理器正在抑制一个被抛入其中的异常.当我将__exit__方法更改为如下所示时:

def __exit__(self, type_, value, trace):
    if trace is not None:
        print('ERROR IN TRACEBACK: ' + str(value))
        # PYTHON 2.7 RAISE SYNTAX:
        raise type_, value, trace

这些错误似乎正确地通过了.

我的问题是:如果type_,value和trace不是None,那么在__exit__方法中处理异常的正确方法是什么？提升(重新加注？)这样的例外是不是很糟糕？这是我应该怎么做的？

我遇到的错误可能是由其他原因造成的.通常我会仔细检查这一切,但我的时间似乎非常有限.我希望有人可以解释这个功能的正确实现

最终:我可以在上下文管理器__exit__方法中安全地保留raise type_,value,trace吗？

在我的 python 程序中，我想在一个很长的循环中打印进度。我想输出特定信息，如完成百分比等...，但我不希望所有这些输出占据整个屏幕。

理想情况下，我想打印进度线。就像是

train 53/56...x6 ? loss:1.356 ? miou:0.276 ? rate=3.13 Hz, eta=0:00:01, total=0:00:17, wall=19:48 EST

然后，当下一行打印时，我想简单地覆盖这一行。

目前，我可以通过'\r'在打印消息之前简单地打印回车来完成此操作。这会将光标返回到行的开头，然后覆盖该行。正是我想要的。

问题是当终端太小而无法容纳整行时，该行环绕并且回车将我带到环绕行的开头，而不是该行的绝对开头。

有没有办法可以让光标一直回到正确行的开头？

我正在努力使用 sqlalchemy 定义一个模式，该模式可与多个引擎后端一起使用，特别是 sqlite 和 postgresql。

我遇到问题，因为我有一个带有索引的 JSON 列。这似乎适用于 sqlite，但对于 postgresql，它会抱怨索引类型不能是 btree。我看过突出显示特定于 postgres 方言的 JSONB 类型的文档，但问题是我的架构是声明性的：我不知道是否要连接到 SQLite 或 PostgreSQL 数据库。

作为示例，以下是一个玩具声明性模式：

    # from sqlalchemy.dialects.postgresql import JSONB
    from sqlalchemy import create_engine
    from sqlalchemy import inspect
    from sqlalchemy.ext.declarative import declarative_base
    from sqlalchemy.orm import sessionmaker
    from sqlalchemy.sql.schema import Column, Index
    from sqlalchemy.types import Integer, JSON
    from sqlalchemy_utils import database_exists, create_database

    CustomBase = declarative_base()

    class User(CustomBase):
        __tablename__ = 'users'
        id = Column(Integer, primary_key=True, doc='unique internal id')
        name = Column(JSON)
        loose_identifer = Column(JSON, index=True, unique=False) …

我希望能够在Python的标准Random和numpy的np.random.RandomState之间来回转换.这两个都使用Mersenne Twister算法,因此它应该是可能的(除非他们使用此算法的不同版本).

我开始研究这些对象的getstate/setstate和get_state/set_state方法.但我不知道如何转换它们的细节.

import numpy as np
import random

rng1 = np.random.RandomState(seed=0)
rng2 = random.Random(seed=0)

state1 = rng1.get_state()
state2 = rng2.getstate()

检查每个州,我看到:

>>> print(state1) 
('MT19937', array([0, 1, 1812433255, ..., 1796872496], dtype=uint32), 624, 0, 0.0)
>>> print(state2) 
(3, (2147483648, 766982754, ..., 1057334138, 2902720905, 624), None)

第一个状态是大小为5的元组len(state1[1]) = 624.

第二个状态是大小为3的元组len(state2[1]) = 625.似乎state2中的最后一项实际上是state1中的624,这意味着数组实际上是相同的大小.到现在为止还挺好.这些似乎相当兼容.

不幸的是,内部数字没有明显的对应关系,所以0的种子导致不同的状态,这是有道理的,因为rng1.rand() = .548和rng2.random() = .844.所以,算法似乎略有不同.

但是,我不需要它们完美对应.我只需要能够在不影响第一个状态的情况下确定性地设置一个rng的状态.

理想情况下,一旦我使用第一个的状态来设置第二个的状态,而不调用任何随机方法,然后使用第二个来设置第一个的状态,第一个状态将保持不变,但这不是一个要求.

目前我有一个黑客攻击方法,只是交换我可以从两个rng中提取的624长度列表.但是,我不确定这种方法是否存在任何问题.任何对这个问题更有见识的人都可以解释一下吗？

这是我的方法,但我不确定它是否正常工作.

np_rng = np.random.RandomState(seed=0)
py_rng = random.Random(0)

# Convert python to numpy random …