在这种情况下，如何使python脚本运行更快或使用多进程？

Question

我正在尝试在800K对文档中测量四个相似度（cosine_similarity，jaccard，Sequence Matcher相似度，jaccard_variants相似度）。

每个文档文件都是txt格式，大约100KB〜300KB（大约1500000个字符）。

关于如何使我的python脚本更快，我有两个问题：

我的PYTHON脚本：

from sklearn.feature_extraction.text import CountVectorizer
from sklearn.metrics.pairwise import cosine_similarity
from difflib import SequenceMatcher

def get_tf_vectors(doc1, doc2):
    text = [doc1, doc2]
    vectorizer = CountVectorizer(text)
    vectorizer.fit(text)
    return vectorizer.transform(text).toarray()

def measure_sim(doc1, doc2):
    a, b = doc1.split(), doc2.split()
    c, d = set(a), set(b)
    vectors = [t for t in get_tf_vectors(doc1, doc2)]
    return cosine_similarity(vectors)[1][0], float(len(c&d) / len(c|d)), \
            1 - (sum(abs(vectors[0] - vectors[1])) / sum(vectors[0] + vectors[1])), \
            SequenceMatcher(None, a, b).ratio()

#items in doc_pair list are like('ID', 'doc1_directory', 'doc2_directory')
def data_analysis(doc_pair_list):
    result = {}
    for item in doc_pair_list:
        f1 = open(item[1], 'rb')
        doc1 = f1.read()
        f1.close()
        f2 = oepn(item[2], 'rb')
        doc2 = f2.read()
        f2.close()
        result[item[0]] = measure_sim(doc1, doc2)

但是，此代码仅占用我10％的CPU，并且几乎需要20天才能完成此任务。 因此，我想问一下是否有任何方法可以使此代码更有效。

Q1。 由于文档保存在HDD中，因此我认为加载这些文本数据需要一些时间。 因此，我怀疑每次计算机计算相似度时仅加载两个文档可能效率不高。 因此，我将尝试一次加载50对文档并分别计算相似度。 这会有所帮助吗？

Q2。 关于“如何使代码运行更快”的大多数帖子都说我应该使用基于C代码的Python模块。 但是，由于我使用的是效率很高的sklearn模块，所以我想知道还有没有更好的方法。

有什么方法可以帮助此python脚本使用更多计算机资源并变得更快？

Answer 1

也许有更好的解决方案，但如果阻止相似性计数，您可以尝试这样的方法：1）一个单独的过程，一个接一个地读取所有文件并将其放入多处理队列。2）多个工作程序池计数相似性并将结果放入multiprocessing.Queue的过程。 3）然后，主线程只需从results_queue加载结果，然后将其保存到字典中即可。

我不知道您的硬件限制（CPU内核的数量和速度，RAM大小，磁盘读取速度），并且我没有任何样本可以对其进行测试。 编辑：下面提供了描述的代码。 请尝试检查是否更快，并通知我。 如果主阻止程序正在加载文件，则我们可以创建更多的加载程序进程（例如2个进程，每个进程都加载一半文件）。 如果阻止程序正在计算相似性，则可以创建更多工作进程（只需更改worker_count）。 最后，“结果”是包含所有结果的字典。

    import multiprocessing
    import os
    from difflib import SequenceMatcher
    from sklearn.feature_extraction.text import CountVectorizer
    from sklearn.metrics.pairwise import cosine_similarity


    def get_tf_vectors(doc1, doc2):
        text = [doc1, doc2]
        vectorizer = CountVectorizer(text)
        vectorizer.fit(text)
        return vectorizer.transform(text).toarray()


    def calculate_similarities(doc_pairs_queue, results_queue):
        """ Pick docs from doc_pairs_queue and calculate their similarities, save the result to results_queue. Repeat infinitely (until process is terminated). """
        while True:
            pair = doc_pairs_queue.get()
            pair_id = pair[0]
            doc1 = pair[1]
            doc2 = pair[2]
            a, b = doc1.split(), doc2.split()
            c, d = set(a), set(b)
            vectors = [t for t in get_tf_vectors(doc1, doc2)]
            results_queue.put((pair_id, cosine_similarity(vectors)[1][0], float(len(c&d) / len(c|d)),
                1 - (sum(abs(vectors[0] - vectors[1])) / sum(vectors[0] + vectors[1])),
                SequenceMatcher(None, a, b).ratio()))


    def load_files(doc_pair_list, loaded_queue):
        """
        Pre-load files and put them to a queue, so working processes can get them.
        :param doc_pair_list: list of files to be loaded (ID, doc1_path, doc2_path)
        :param loaded_queue: multiprocessing.Queue that will hold pre-loaded data
        """
        print("Started loading files...")
        for item in doc_pair_list:
            with open(item[1], 'rb') as f1:
                with open(item[2], 'rb') as f2:
                    loaded_queue.put((item[0], f1.read(), f2.read()))  # if queue is full, this automatically waits until there is space

        print("Finished loading files.")


    def data_analysis(doc_pair_list):
        # create a loader process that will pre-load files (it does no calculations, so it loads much faster)
        # loader puts loaded files to a queue; 1 pair ~ 500 KB, 1000 pairs ~ 500 MB max size of queue (RAM memory)
        loaded_pairs_queue = multiprocessing.Queue(maxsize=1000)
        loader = multiprocessing.Process(target=load_files, args=(doc_pair_list, loaded_pairs_queue))
        loader.start()

        # create worker processes - these will do all calculations
        results_queue = multiprocessing.Queue(maxsize=1000)  # workers put results to this queue
        worker_count = os.cpu_count() if os.cpu_count() else 2  # number of worker processes
        workers = []  # create list of workers, so we can terminate them later
        for i in range(worker_count):
            worker = multiprocessing.Process(target=calculate_similarities, args=(loaded_pairs_queue, results_queue))
            worker.start()
            workers.append(worker)

        # main process just picks the results from queue and saves them to the dictionary
        results = {}
        i = 0  # results counter
        pairs_count = len(doc_pair_list)
        while i < pairs_count:
            res = results_queue.get(timeout=600)  # timeout is just in case something unexpected happened (results are calculated much quicker)
            # Queue.get() is blocking - if queue is empty, get() waits until something is put into queue and then get it
            results[res[0]] = res[1:]  # save to dictionary by ID (first item in the result)

        # clean up the processes (so there aren't any zombies left)
        loader.terminate()
        loader.join()
        for worker in workers:
            worker.terminate()
            worker.join()

请让我知道结果，我对此非常感兴趣，并在需要时为您提供进一步的帮助;）

Answer 2

首先要做的就是看看您是否能找到真正的瓶颈，我认为使用cProfile可能会证实您的怀疑或进一步揭示您的问题。

您应该能够像这样使用cProfile运行未经修改的代码：

python -m cProfile -o profiling-results python-file-to-test.py

之后，您可以使用pstats分析结果，如下所示：

import pstats
stats = pstats.Stats("profiling-results")
stats.sort_stats("tottime")

stats.print_stats(10)

Marco Bonazanin的博客文章My Python Code is Slow？是有关分析代码的更多信息。 分析技巧