并发Psycopg2 Postgres选择查询的结果为空

Question

我正在尝试使用自定义pytorch数据集中的getitem方法从postgres数据库中检索标签和要素数据集。 当我尝试使用随机索引采样时，我的查询没有返回结果

我检查了查询是否直接在psql cli上工作。 他们是这样。 我已经检查了数据库连接池中的问题。 似乎没有。 我已经恢复为顺序采样，它仍然可以正常运行，因此随机索引值似乎是查询的问题。

执行查询的getitem方法位于下面。 这既显示了顺序查询，也显示了随机查询的尝试。 这两个变量均通过变量名清楚地标记。

def __getitem__(self, idx):

        query = """SELECT ls.taxonomic_id, it.tensor
                    FROM genomics.tensors2 AS it
                    INNER JOIN genomics.labeled_sequences AS ls
                    ON ls.accession_number = it.accession_number
                    WHERE (%s) <= it.index 
                    AND CARDINALITY(tensor) = 89
                    LIMIT (%s) OFFSET (%s)"""

        shuffle_query = """BEGIN
                           SELECT ls.taxonomic_id, it.tensor
                           FROM genomics.tensors2 AS it
                           INNER JOIN genomics.labeled_sequences AS ls
                           ON ls.accession_number = it.accession_number
                           WHERE it.index BETWEEN (%s) AND (%s)
                           END"""


        batch_size = 500
        upper_bound = idx + batch_size

        query_data = (idx, batch_size, batch_size)
        shuffle_query_data = (idx, upper_bound)

        result = None
        results = None

        conn = self.conn_pool.getconn() 

        try:
            conn.set_session(readonly=True, autocommit=True)
            cursor = conn.cursor()
            cursor.execute(query, query_data)
            results = cursor.fetchall()
            self.conn_pool.putconn(conn)


            print(idx)
            print(results)        
        except Error as conn_pool_error:
            print('Multithreaded __getitem__ query error')
            print(conn_pool_error)

        label_list = []
        sequence_list = []

        for (i,result) in enumerate(results):
            if result is not None:
                (label, sequence) = self.create_batch_stack_element(result)

                label_list.append(label)
                sequence_list.append(sequence)

        label_stack = torch.stack(label_list).to('cuda')
        sequence_stack = torch.stack(sequence_list).to('cuda')

        return (label_stack, sequence_stack)


    def create_batch_stack_element(self, result):
        if result is not None:

            label = np.array(result[0], dtype=np.int64)
            sequence = np.array(result[1], dtype=np.int64)

            label = torch.from_numpy(label)
            sequence = torch.from_numpy(sequence)

            return (label, sequence)

        else:
            return None

我收到的错误是由于我尝试在for循环之后堆叠张量列表而引起的。 由于列表为空，因此失败。 由于列表是根据查询结果填充到循环中的。 它指出查询是问题所在。

我希望在源代码方面提供一些帮助来解决此问题，并可能需要解释为什么我的带有随机索引的并发查询失败了。

谢谢。 任何帮助表示赞赏。

E：我相信我已经找到问题的根源，并且来自pytorch RandomSampler源代码。 我相信它提供的索引超出了我的数据库密钥范围。 这解释了为什么我没有查询结果。 我将不得不编写自己的采样器类以将该值限制为数据集的长度。 我这真是一个疏忽。

E2：现在，随机采样可与自定义采样器类一起使用，但可以防止多线程查询。

E3：我现在解决了整个问题。 使用多个过程通过自定义随机采样器将数据加载到GPU。 有机会时将发布适用的代码，并接受它作为结束线程的答案。

Answer 1

这是带有可索引键的postgres表中pytorch的正确构造的getitem。

def __getitem__(self, idx: int) -> tuple:

    query = """SELECT ls.taxonomic_id, it.tensor
               FROM genomics.tensors2 AS it
               INNER JOIN genomics.labeled_sequences AS ls
               ON ls.accession_number = it.accession_number
               WHERE (%s) = it.index"""

    query_data = (idx,)

    result = None

    conn = self.conn_pool.getconn()

    try:
        conn.set_session(readonly=True, autocommit=True)
        cursor = conn.cursor()
        cursor.execute(query, query_data)
        result = cursor.fetchone()

        self.conn_pool.putconn(conn)
    except Error as conn_pool_error:
        print('Multithreaded __getitem__ query error')
        print(conn_pool_error)

    return result

def collate(self, results: list) -> tuple:

    label_list = []
    sequence_list = []

    for result in results:
        if result is not None:
            print(result)
            result = self.create_batch_stack_element(result)

            if result is not None:
                label_list.append(result[0])
                sequence_list.append(result[1])

    label_stack = torch.stack(label_list)
    sequence_stack = torch.stack(sequence_list)

    return (label_stack, sequence_stack)



def create_batch_stack_element(self, result: tuple) -> tuple:

    if result is not None:

        label = np.array(result[0], dtype=np.int64)
        sequence = np.array(result[1], dtype=np.int64)

        label = torch.from_numpy(label)
        sequence = torch.from_numpy(sequence)

        return (label, sequence)

    return None

然后我用以下命令调用了我的训练函数：

for rank in range(num_processes):
    p = mp.Process(target=train, args=(dataloader,))
    p.start()
    processes.append(p)
for p in processes:
    p.join()