python - np.where 如何使用正则表达式提高性能？

Question

我是 python numpy 和正则表达式的新手。我正在尝试从每一行的 Pandas 文本列中提取模式。根据我的要求，有许多可能的情况可用，因此我在下面写了不同的正则表达式。为了迭代和搜索给定的模式，我正在使用 python 的 np.where 但我遇到了性能问题。是否有任何方法可以提高性能或任何替代方案来实现以下输出。

x_train['Description'] is my pandas column.

54672 rows in my dataset.


Code:

pattern1 = re.compile(r'\bAGE[a-z]?\b[\s\w]*\W+\d+.*(?:year[s]|month[s]?)',re.I)

pattern2 = re.compile(r'\bfor\b[\s]*age[s]?\W+\d+\W+(?:month[s]?|year[s]?)',re.I)

pattern3 = re.compile(r'\badult[s]?.[\w\s]\d+',re.I)

pattern4 = re.compile(r'\b\d+\W+(?:month[s]?|year[s]?)\W+of\W+age[a-z]?',re.I)

pattern5 = re.compile(r'[a-z][a-z\s]+(?:month[s]?|year[s]?)[\w\s]+age[s]?',re.I) 

pattern6 = re.compile(r'\bage.*?\s\d+[\s]*\+',re.I)

pattern7 = re.compile(r'\bbetween[\s]*age[s]?[\s]*\d+.*(?:month[s]?|year[s]?)',re.I)

pattern8 = re.compile(r'\b\d+[\w+\s]*?(?:\band\sup\b|\band\sabove\b|\band\sold[a-z]*\b)',re.I)

np_time = time.time()

x_train['pattern'] = np.where(x_train['Description'].str.contains(pattern1), x_train['Description'].str.findall(pattern1),

                              np.where (x_train['Description'].str.contains(pattern2), x_train['Description'].str.findall(pattern2),

                              np.where (x_train['Description'].str.contains(pattern3), x_train['Description'].str.findall(pattern3),

                              np.where (x_train['Description'].str.contains(pattern4), x_train['Description'].str.findall(pattern4),  

                              np.where (x_train['Description'].str.contains(pattern5), x_train['Description'].str.findall(pattern5),  

                              np.where (x_train['Description'].str.contains(pattern6), x_train['Description'].str.findall(pattern6),  

                              np.where (x_train['Description'].str.contains(pattern7), x_train['Description'].str.findall(pattern7),  

                              np.where (x_train['Description'].str.contains(pattern8), x_train['Description'].str.findall(pattern8),                                


                                                'NO PATTERN')      

                                                             )))))))


print "pattern extraction ran in = "
print("--- %s seconds ---" % (time.time() - np_time))



pattern extraction ran in = 
--- 99.5106501579 seconds ---

上面代码的示例输入和输出

        Description                                  pattern     

    0  **AGE RANGE: 6 YEARS** AND UP 10' LONG          AGE RANGE: 6 YEARS 
       STRING OF BEAUTIFUL LIGHTS MULTIPLE 
       LIGHT EFFECTS FADE IN AND OUT

    1  DIMENSIONS   OVERALL HEIGHT - TOP           AGE GROUP: -2 YEARS/3 TO 4 
       TO BOTTOM: 34.5'' OVERALL WIDTH - SIDE      YEARS/5 TO 6 YEARS/7 TO 8 
                                                   YEARS/7 TO 8 YEARS.
       TO SIDE: 20''  OVERALL DEPTH - 
       FRONT TO BACK:      15''  COUNTER TOP 
       HEIGHT - TOP TO BOTTOM: 23''  OVERALL 
       PRODUCT WEIGHT: 38 LBS "   
       **"AGE GROUP: -2 YEARS/3 TO 4 YEARS/5 TO 6 
        YEARS/7 TO 8 YEARS**.

   2   THE FLAME-RETARDANT FOAM ALSO CONTAINS              AGED 1-5 YEARS
       ANTIMICROBIAL PROTECTION, SO IT WON'T GROW 
       MOLD OR BACTERIA IF IT GETS WET. THE 
       BRIGHTLY-COLORED 
       VINYL EXTERIOR IS EASY TO WIPE CLEAN. FOAMMAN 
       IS DESIGNED FOR KIDS **AGED 1-5 YEARS**

Answer 1

有几件事你可以尝试:

首先，您需要识别速度较慢的正则表达式。例如，您可以使用 https://regex101.com/ 执行此操作观察 'steps' 值。

我检查了正则表达式，5 号和 8 号是最慢的。

27800 steps = [a-z][a-z\s]+(?:month[s]?|year[s]?)[\w\s]+age[s]?
 4404 steps= \b\d+[\w+\s]*?(?:\band\sup\b|\band\sabove\b|\band\sold[a-z]*\b)

您可能会考虑优化这 2 个正则表达式。

例如，您可以重写此 \b\d+[\w+\s]*?(?:\band\sup\b|\band\sabove\b|\band\sold[a-z]*\b)

进入这个 \b\d+[\w+\s]*?(?:\band\s(?:up|above|old[a-z]*\b)) ，它使用了 about步骤减少 50%。

对于另一个正则表达式，有几个选项。您可以将其重写为:

[A-Z][A-LN-XZ\s]+(?:(?:Y(?!EARS?)|M(?!ONTHS?))[A-LN-XZ\s] +)*(?:MONTHS?|YEARS?)[\w\s]+AGE[S]?

哪个更快一些。不多，虽然(27800 对 23800)

然而，它真正加快速度的是让它区分大小写。

区分大小写的原始正则表达式仅执行 3700 步。以及优化后的 1470。

因此您可以将整个字符串大写/小写并在您的(区分大小写的)正则表达式中使用它。您甚至可能不需要转换您的字符串，因为在您的示例中它似乎是大写的。

另一件要看的事情是被测试的正则表达式的顺序。如果有一些正则表达式比其他的更有可能匹配，则应首先测试它们。

如果您不知道这些概率并且您认为它们或多或少相同，您可以考虑先放置更简单的正则表达式。一如既往地测试难以匹配的复杂正则表达式是浪费时间。

最后，当您有诸如 (a|b|c) 的选项时，您可以考虑将最有可能放在开头，原因与之前相同。