How to improve cython code to make it faster than numpy select f

ghz 8months ago ⋅ 130 views

How to improve cython code to make it faster than numpy select function?

I am trying to make a code faster than "numpy select" but it is slower than numpy. numpy select is twice faster than my cython code. I tried big dataset and small dataset but both of cases numpy select is faster (numpy select 11.4ms, cython code 24ms)

I tried methods in the cython documents but failed to reduce speed gap. Here is my detailed cython code.

Used packages

import numpy as np
import pandas as pd
import cython
import random
import timeit
import time
%load_ext Cython

Used dataset

dur_m = np.random.randint(1, 1001, size=100000)
pol_year = np.random.randint(1, 1001, size=100000)
calc_flag = 1
type = np.random.choice(['IF','NB', 'NB2', 'NB3'], size = 100000)

rand = np.arange(0.01, 0.05, 0.0001)
output1 = np.random.choice(rand, size=100000)
output2 = np.random.choice(rand, size=100000)
output3 = np.random.choice(rand, size=100000)

Numpy test

def compute_np(t):
    
    condition = [
    (t > dur_m) & (t < pol_year) & (calc_flag ==1),
    (t < dur_m) & (calc_flag ==1),
    (t < pol_year)
    ]
        
    result = [
    output1,
    output2,
    output3
    ]

    default = np.array([0] * 100000)

    return np.select(condition, result, default)

Cython code

%%cython --annotate
import cython
cimport cython
import numpy as np
cimport numpy as np
@cython.boundscheck(False)
@cython.wraparound(False)
def select_cy2(np.ndarray[np.uint8_t, ndim = 2, cast=True] conditions, double [:, ::1] choice, double [:] default_value):
    cdef int num_condition = conditions.shape[0]
    cdef int length = conditions.shape[1]
    cdef np.ndarray[np.float64_t, ndim=1] result = np.zeros(length, dtype=np.float64)
    cdef int i, j
    for j in range(length):
        for i in range(num_condition):
            if conditions[i,j]:
                result[j] = choice[i,j]
                break
            else:
                result[j] = default_value[i]
    return result

Cython test

def compute_cy(t):
    
    condition = [
    (t > dur_m) & (t < pol_year) & (np.array([calc_flag]*100000) ==1), 
    (t < dur_m) & (np.array([calc_flag]*100000) ==1), 
    (t < pol_year)]
        
    result = [
    output1, 
    output2, 
    output3]

    default = np.array([0.0] * 100000)

    return select_cy(np.array(condition), np.array(result), default)

Is there anyone who can suggest the method to improve the speed?

Answers

To improve the speed of your Cython code, you can try the following optimizations:

  1. Reduce Python overhead: Try to minimize the Python overhead by moving as much computation as possible into pure C code. This means minimizing the number of Python function calls and Python object creations.

  2. Optimize memory access: Ensure that memory access is as efficient as possible. This includes avoiding unnecessary memory allocations and copying, and making use of contiguous memory access wherever possible.

  3. Use typed memory views: Consider using typed memory views (double[:, ::1]) instead of NumPy arrays in your Cython code. Typed memory views provide more efficient memory access compared to NumPy arrays.

  4. Parallelize computation: If possible, parallelize the computation using threading or multiprocessing. This can help leverage multiple CPU cores and improve overall performance.

  5. Profile and optimize: Use profiling tools to identify bottlenecks in your code and focus optimization efforts on those areas. Profiling can help you identify where most of the time is being spent and where optimizations are likely to have the biggest impact.

Here's an optimized version of your Cython code incorporating some of these suggestions:

%%cython --annotate
import numpy as np
cimport numpy as np

@cython.boundscheck(False)
@cython.wraparound(False)
def select_cy(np.ndarray[np.float64_t, ndim=2] conditions, np.ndarray[np.float64_t, ndim=2] choice, np.float64_t[:] default_value):
    cdef int num_condition = conditions.shape[0]
    cdef int length = conditions.shape[1]
    cdef np.ndarray[np.float64_t, ndim=1] result = np.zeros(length, dtype=np.float64)
    cdef int i, j
    for j in range(length):
        for i in range(num_condition):
            if conditions[i,j]:
                result[j] = choice[i,j]
                break
            else:
                result[j] = default_value[i]
    return result

def compute_cy(t, dur_m, pol_year, calc_flag, output1, output2, output3):
    condition = [
        (t > dur_m) & (t < pol_year) & (calc_flag == 1), 
        (t < dur_m) & (calc_flag == 1), 
        (t < pol_year)]
        
    result = [output1, output2, output3]
    default = np.zeros(100000, dtype=np.float64)

    return select_cy(np.array(condition, dtype=np.float64), np.array(result, dtype=np.float64), default)

In this version, I've used typed memory views for the input arrays and avoided unnecessary memory allocations by pre-allocating the result array. Additionally, I've removed unnecessary conversions and simplified the condition construction in the compute_cy function.

#cython