python - guia - Conversión de una serie de pasos en cadenas: ¿por qué se aplica mucho más rápido que un astype?

qgis manual

Question

Tengo un pandas.Series contienen enteros, pero necesito convertirlos en cadenas para algunas herramientas pandas.Series . Supongamos que tengo un objeto de la Series :

import numpy as np
import pandas as pd

x = pd.Series(np.random.randint(0, 100, 1000000))

En StackOverflow y otros sitios web, he visto a la mayoría de las personas argumentar que la mejor manera de hacerlo es:

%% timeit
x = x.astype(str)

Esto lleva unos 2 segundos.

Cuando uso x = x.apply(str) , solo toma 0.2 segundos.

¿Por qué x.astype(str) tan lento? ¿Debería la forma recomendada ser x.apply(str) ?

Estoy principalmente interesado en el comportamiento de python 3 para esto.

Answer 1

Comencemos con un poco de consejos generales: si está interesado en encontrar los cuellos de botella del código Python, puede usar un generador de perfiles para encontrar las funciones / partes que consumen la mayor parte del tiempo. En este caso, uso un perfilador de línea porque realmente puede ver la implementación y el tiempo empleado en cada línea.

Sin embargo, estas herramientas no funcionan con C o Cython de forma predeterminada. Dado que CPython (que es el intérprete de Python que estoy usando), NumPy y los pandas hacen un uso intensivo de C y Cython, habrá un límite de cuánto llegaré con la creación de perfiles.

En realidad: probablemente se podría extender el perfilado al código de Cython y probablemente también al código C al compilarlo con símbolos de depuración y seguimiento, sin embargo, no es una tarea fácil compilar estas bibliotecas, así que no haré eso (pero si a alguien le gusta hacerlo que la documentación de Cython incluye una página sobre cómo crear un perfil de código de Cython ).

Pero veamos hasta dónde puedo llegar:

Código de línea de Python código

Voy a usar line-profiler y un cuaderno de Jupyter aquí:

%load_ext line_profiler

import numpy as np
import pandas as pd

x = pd.Series(np.random.randint(0, 100, 100000))

Perfil x.astype

%lprun -f x.astype x.astype(str)

Line #      Hits         Time  Per Hit   % Time  Line Contents
==============================================================
    87                                                   @wraps(func)
    88                                                   def wrapper(*args, **kwargs):
    89         1           12     12.0      0.0              old_arg_value = kwargs.pop(old_arg_name, None)
    90         1            5      5.0      0.0              if old_arg_value is not None:
    91                                                           if mapping is not None:
   ...
   118         1       663354 663354.0    100.0              return func(*args, **kwargs)

Así que eso es simplemente un decorador y el 100% del tiempo se gasta en la función decorada. Así que vamos a perfilar la función decorada:

%lprun -f x.astype.__wrapped__ x.astype(str)

Line #      Hits         Time  Per Hit   % Time  Line Contents
==============================================================
  3896                                               @deprecate_kwarg(old_arg_name=''raise_on_error'', new_arg_name=''errors'',
  3897                                                                mapping={True: ''raise'', False: ''ignore''})
  3898                                               def astype(self, dtype, copy=True, errors=''raise'', **kwargs):
  3899                                                   """
  ...
  3975                                                   """
  3976         1           28     28.0      0.0          if is_dict_like(dtype):
  3977                                                       if self.ndim == 1:  # i.e. Series
  ...
  4001                                           
  4002                                                   # else, only a single dtype is given
  4003         1           14     14.0      0.0          new_data = self._data.astype(dtype=dtype, copy=copy, errors=errors,
  4004         1       685863 685863.0     99.9                                       **kwargs)
  4005         1          340    340.0      0.0          return self._constructor(new_data).__finalize__(self)

Source

Una vez más, una línea es el cuello de botella, así que _data.astype método _data.astype :

%lprun -f x._data.astype x.astype(str)

Line #      Hits         Time  Per Hit   % Time  Line Contents
==============================================================
  3461                                               def astype(self, dtype, **kwargs):
  3462         1       695866 695866.0    100.0          return self.apply(''astype'', dtype=dtype, **kwargs)

Bien, otro delegado, veamos lo que _data.apply hace:

%lprun -f x._data.apply x.astype(str)

Line #      Hits         Time  Per Hit   % Time  Line Contents
==============================================================
  3251                                               def apply(self, f, axes=None, filter=None, do_integrity_check=False,
  3252                                                         consolidate=True, **kwargs):
  3253                                                   """
  ...
  3271                                                   """
  3272                                           
  3273         1           12     12.0      0.0          result_blocks = []
  ...
  3309                                           
  3310         1           10     10.0      0.0          aligned_args = dict((k, kwargs[k])
  3311         1           29     29.0      0.0                              for k in align_keys
  3312                                                                       if hasattr(kwargs[k], ''reindex_axis''))
  3313                                           
  3314         2           28     14.0      0.0          for b in self.blocks:
  ...
  3329         1       674974 674974.0    100.0              applied = getattr(b, f)(**kwargs)
  3330         1           30     30.0      0.0              result_blocks = _extend_blocks(applied, result_blocks)
  3331                                           
  3332         1           10     10.0      0.0          if len(result_blocks) == 0:
  3333                                                       return self.make_empty(axes or self.axes)
  3334         1           10     10.0      0.0          bm = self.__class__(result_blocks, axes or self.axes,
  3335         1           76     76.0      0.0                              do_integrity_check=do_integrity_check)
  3336         1           13     13.0      0.0          bm._consolidate_inplace()
  3337         1            7      7.0      0.0          return bm

Source

Y de nuevo ... una llamada de función está tomando todo el tiempo, esta vez es x._data.blocks[0].astype :

%lprun -f x._data.blocks[0].astype x.astype(str)

Line #      Hits         Time  Per Hit   % Time  Line Contents
==============================================================
   542                                               def astype(self, dtype, copy=False, errors=''raise'', values=None, **kwargs):
   543         1           18     18.0      0.0          return self._astype(dtype, copy=copy, errors=errors, values=values,
   544         1       671092 671092.0    100.0                              **kwargs)

.. que es otro delegado ...

%lprun -f x._data.blocks[0]._astype x.astype(str)

Line #      Hits         Time  Per Hit   % Time  Line Contents
==============================================================
   546                                               def _astype(self, dtype, copy=False, errors=''raise'', values=None,
   547                                                           klass=None, mgr=None, **kwargs):
   548                                                   """
   ...
   557                                                   """
   558         1           11     11.0      0.0          errors_legal_values = (''raise'', ''ignore'')
   559                                           
   560         1            8      8.0      0.0          if errors not in errors_legal_values:
   561                                                       invalid_arg = ("Expected value of kwarg ''errors'' to be one of {}. "
   562                                                                      "Supplied value is ''{}''".format(
   563                                                                          list(errors_legal_values), errors))
   564                                                       raise ValueError(invalid_arg)
   565                                           
   566         1           23     23.0      0.0          if inspect.isclass(dtype) and issubclass(dtype, ExtensionDtype):
   567                                                       msg = ("Expected an instance of {}, but got the class instead. "
   568                                                              "Try instantiating ''dtype''.".format(dtype.__name__))
   569                                                       raise TypeError(msg)
   570                                           
   571                                                   # may need to convert to categorical
   572                                                   # this is only called for non-categoricals
   573         1           72     72.0      0.0          if self.is_categorical_astype(dtype):
   ...
   595                                           
   596                                                   # astype processing
   597         1           16     16.0      0.0          dtype = np.dtype(dtype)
   598         1           19     19.0      0.0          if self.dtype == dtype:
   ...
   603         1            8      8.0      0.0          if klass is None:
   604         1           13     13.0      0.0              if dtype == np.object_:
   605                                                           klass = ObjectBlock
   606         1            6      6.0      0.0          try:
   607                                                       # force the copy here
   608         1            7      7.0      0.0              if values is None:
   609                                           
   610         1            8      8.0      0.0                  if issubclass(dtype.type,
   611         1           14     14.0      0.0                                (compat.text_type, compat.string_types)):
   612                                           
   613                                                               # use native type formatting for datetime/tz/timedelta
   614         1           15     15.0      0.0                      if self.is_datelike:
   615                                                                   values = self.to_native_types()
   616                                           
   617                                                               # astype formatting
   618                                                               else:
   619         1            8      8.0      0.0                          values = self.values
   620                                           
   621                                                           else:
   622                                                               values = self.get_values(dtype=dtype)
   623                                           
   624                                                           # _astype_nansafe works fine with 1-d only
   625         1       665777 665777.0     99.9                  values = astype_nansafe(values.ravel(), dtype, copy=True)
   626         1           32     32.0      0.0                  values = values.reshape(self.shape)
   627                                           
   628         1           17     17.0      0.0              newb = make_block(values, placement=self.mgr_locs, dtype=dtype,
   629         1          269    269.0      0.0                                klass=klass)
   630                                                   except:
   631                                                       if errors == ''raise'':
   632                                                           raise
   633                                                       newb = self.copy() if copy else self
   634                                           
   635         1            8      8.0      0.0          if newb.is_numeric and self.is_numeric:
   ...
   642         1            6      6.0      0.0          return newb

Source

... está bien, todavía no está allí. Vamos a ver astype_nansafe :

%lprun -f pd.core.internals.astype_nansafe x.astype(str)

Line #      Hits         Time  Per Hit   % Time  Line Contents
==============================================================
   640                                           def astype_nansafe(arr, dtype, copy=True):
   641                                               """ return a view if copy is False, but
   642                                                   need to be very careful as the result shape could change! """
   643         1           13     13.0      0.0      if not isinstance(dtype, np.dtype):
   644                                                   dtype = pandas_dtype(dtype)
   645                                           
   646         1            8      8.0      0.0      if issubclass(dtype.type, text_type):
   647                                                   # in Py3 that''s str, in Py2 that''s unicode
   648         1       663317 663317.0    100.0          return lib.astype_unicode(arr.ravel()).reshape(arr.shape)
   ...

Source

Nuevamente, una es una línea que toma el 100%, así que voy a ir más allá:

%lprun -f pd.core.dtypes.cast.lib.astype_unicode x.astype(str)

UserWarning: Could not extract a code object for the object <built-in function astype_unicode>

Bien, encontramos una built-in function , eso significa que es una función C. En este caso es una función de Cython. Pero significa que no podemos profundizar más con el perfilador de líneas. Así que voy a parar aquí por ahora.

Perfilado x.apply

%lprun -f x.apply x.apply(str)

Line #      Hits         Time  Per Hit   % Time  Line Contents
==============================================================
  2426                                               def apply(self, func, convert_dtype=True, args=(), **kwds):
  2427                                                   """
  ...
  2523                                                   """
  2524         1           84     84.0      0.0          if len(self) == 0:
  2525                                                       return self._constructor(dtype=self.dtype,
  2526                                                                                index=self.index).__finalize__(self)
  2527                                           
  2528                                                   # dispatch to agg
  2529         1           11     11.0      0.0          if isinstance(func, (list, dict)):
  2530                                                       return self.aggregate(func, *args, **kwds)
  2531                                           
  2532                                                   # if we are a string, try to dispatch
  2533         1           12     12.0      0.0          if isinstance(func, compat.string_types):
  2534                                                       return self._try_aggregate_string_function(func, *args, **kwds)
  2535                                           
  2536                                                   # handle ufuncs and lambdas
  2537         1            7      7.0      0.0          if kwds or args and not isinstance(func, np.ufunc):
  2538                                                       f = lambda x: func(x, *args, **kwds)
  2539                                                   else:
  2540         1            6      6.0      0.0              f = func
  2541                                           
  2542         1          154    154.0      0.1          with np.errstate(all=''ignore''):
  2543         1           11     11.0      0.0              if isinstance(f, np.ufunc):
  2544                                                           return f(self)
  2545                                           
  2546                                                       # row-wise access
  2547         1          188    188.0      0.1              if is_extension_type(self.dtype):
  2548                                                           mapped = self._values.map(f)
  2549                                                       else:
  2550         1         6238   6238.0      3.3                  values = self.asobject
  2551         1       181910 181910.0     95.5                  mapped = lib.map_infer(values, f, convert=convert_dtype)
  2552                                           
  2553         1           28     28.0      0.0          if len(mapped) and isinstance(mapped[0], Series):
  2554                                                       from pandas.core.frame import DataFrame
  2555                                                       return DataFrame(mapped.tolist(), index=self.index)
  2556                                                   else:
  2557         1           19     19.0      0.0              return self._constructor(mapped,
  2558         1         1870   1870.0      1.0                                       index=self.index).__finalize__(self)

Source

De nuevo, es una función que lleva la mayor parte del tiempo: lib.map_infer ...

%lprun -f pd.core.series.lib.map_infer x.apply(str)

Could not extract a code object for the object <built-in function map_infer>

Bueno, esa es otra función de Cython.

Esta vez hay otro colaborador (aunque menos significativo) con ~ 3%: values = self.asobject . Pero ignoraré esto por ahora, porque estamos interesados ​​en los principales contribuyentes.

Entrando en C / Cython

Las funciones llamadas por astype

Esta es la función astype_unicode :

cpdef ndarray[object] astype_unicode(ndarray arr):
    cdef:
        Py_ssize_t i, n = arr.size
        ndarray[object] result = np.empty(n, dtype=object)

    for i in range(n):
        # we can use the unsafe version because we know `result` is mutable
        # since it was created from `np.empty`
        util.set_value_at_unsafe(result, i, unicode(arr[i]))

    return result

Source

Esta función utiliza este ayudante:

cdef inline set_value_at_unsafe(ndarray arr, object loc, object value):
    cdef:
        Py_ssize_t i, sz
    if is_float_object(loc):
        casted = int(loc)
        if casted == loc:
            loc = casted
    i = <Py_ssize_t> loc
    sz = cnp.PyArray_SIZE(arr)

    if i < 0:
        i += sz
    elif i >= sz:
        raise IndexError(''index out of bounds'')

    assign_value_1d(arr, i, value)

Source

Que a su vez utiliza esta función C:

PANDAS_INLINE int assign_value_1d(PyArrayObject* ap, Py_ssize_t _i,
                                  PyObject* v) {
    npy_intp i = (npy_intp)_i;
    char* item = (char*)PyArray_DATA(ap) + i * PyArray_STRIDE(ap, 0);
    return PyArray_DESCR(ap)->f->setitem(v, item, ap);
}

Source

Funciones llamadas por apply

Esta es la implementación de la función map_infer :

def map_infer(ndarray arr, object f, bint convert=1):
    cdef:
        Py_ssize_t i, n
        ndarray[object] result
        object val

    n = len(arr)
    result = np.empty(n, dtype=object)
    for i in range(n):
        val = f(util.get_value_at(arr, i))

        # unbox 0-dim arrays, GH #690
        if is_array(val) and PyArray_NDIM(val) == 0:
            # is there a faster way to unbox?
            val = val.item()

        result[i] = val

    if convert:
        return maybe_convert_objects(result,
                                     try_float=0,
                                     convert_datetime=0,
                                     convert_timedelta=0)

    return result

Source

Con este ayudante:

cdef inline object get_value_at(ndarray arr, object loc):
    cdef:
        Py_ssize_t i, sz
        int casted

    if is_float_object(loc):
        casted = int(loc)
        if casted == loc:
            loc = casted
    i = <Py_ssize_t> loc
    sz = cnp.PyArray_SIZE(arr)

    if i < 0 and sz > 0:
        i += sz
    elif i >= sz or sz == 0:
        raise IndexError(''index out of bounds'')

    return get_value_1d(arr, i)

Source

Que utiliza esta función C:

PANDAS_INLINE PyObject* get_value_1d(PyArrayObject* ap, Py_ssize_t i) {
    char* item = (char*)PyArray_DATA(ap) + i * PyArray_STRIDE(ap, 0);
    return PyArray_Scalar(item, PyArray_DESCR(ap), (PyObject*)ap);
}

Source

Algunas reflexiones sobre el código Cython.

Hay algunas diferencias entre los códigos de Cython que se llaman eventualmente.

La tomada por astype usa unicode mientras que la ruta de apply usa la función pasada. Veamos si eso hace una diferencia (nuevamente, IPython / Jupyter hace que sea muy fácil compilar el código Cython):

%load_ext cython

%%cython

import numpy as np
cimport numpy as np

cpdef object func_called_by_astype(np.ndarray arr):
    cdef np.ndarray[object] ret = np.empty(arr.size, dtype=object)
    for i in range(arr.size):
        ret[i] = unicode(arr[i])
    return ret

cpdef object func_called_by_apply(np.ndarray arr, object f):
    cdef np.ndarray[object] ret = np.empty(arr.size, dtype=object)
    for i in range(arr.size):
        ret[i] = f(arr[i])
    return ret

Sincronización:

import numpy as np

arr = np.random.randint(0, 10000, 1000000)
%timeit func_called_by_astype(arr)
514 ms ± 11.4 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
%timeit func_called_by_apply(arr, str)
632 ms ± 43.5 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

Está bien, hay una diferencia pero está mal , en realidad indicaría que apply sería un poco más lento .

¿Pero recuerda la llamada de objeto que mencioné anteriormente en la función de apply ? ¿Podría ser esa la razón? Veamos:

import numpy as np

arr = np.random.randint(0, 10000, 1000000)
%timeit func_called_by_astype(arr)
557 ms ± 33.1 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
%timeit func_called_by_apply(arr.astype(object), str)
317 ms ± 13.5 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

Ahora se ve mejor. La conversión a una matriz de objetos hizo que la función llamada aplicara mucho más rápido. Hay una razón simple para esto: str es una función de Python y generalmente son mucho más rápidas si ya tiene objetos de Python y NumPy (o Pandas) no necesita crear un contenedor de Python para el valor almacenado en la matriz (que es generalmente no es un objeto de Python, excepto cuando la matriz es de object dtype).

Sin embargo, eso no explica la gran diferencia que has visto. Mi sospecha es que en realidad hay una diferencia adicional en las formas en que se repiten las matrices y se establecen los elementos en el resultado. Muy probablemente el:

val = f(util.get_value_at(arr, i))
if is_array(val) and PyArray_NDIM(val) == 0:
    val = val.item()
result[i] = val

parte de la función map_infer es más rápida que:

for i in range(n):
    # we can use the unsafe version because we know `result` is mutable
    # since it was created from `np.empty`
    util.set_value_at_unsafe(result, i, unicode(arr[i]))

que es llamado por el astype(str) . Los comentarios de la primera función parecen indicar que el escritor de map_infer realmente intentó hacer el código lo más rápido posible (vea el comentario sobre "¿hay una manera más rápida de desempaquetar?" Mientras que la otra tal vez fue escrita sin especial cuidado rendimiento, pero eso es sólo una conjetura.

También en mi computadora estoy bastante cerca del rendimiento de x.astype(str) y x.apply(str) ya:

import numpy as np

arr = np.random.randint(0, 100, 1000000)
s = pd.Series(arr)
%timeit s.astype(str)
535 ms ± 23.8 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
%timeit func_called_by_astype(arr)
547 ms ± 21.1 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)


%timeit s.apply(str)
216 ms ± 8.48 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
%timeit func_called_by_apply(arr.astype(object), str)
272 ms ± 12.5 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

Tenga en cuenta que también he comprobado algunas otras variantes que devuelven un resultado diferente:

%timeit s.values.astype(str)  # array of strings
407 ms ± 8.56 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
%timeit list(map(str, s.values.tolist()))  # list of strings
184 ms ± 5.02 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

Curiosamente, el bucle de Python con la list y el map parece ser el más rápido en mi computadora.

En realidad hice un pequeño punto de referencia que incluye la trama

import pandas as pd
import simple_benchmark

def Series_astype(series):
    return series.astype(str)

def Series_apply(series):
    return series.apply(str)

def Series_tolist_map(series):
    return list(map(str, series.values.tolist()))

def Series_values_astype(series):
    return series.values.astype(str)


arguments = {2**i: pd.Series(np.random.randint(0, 100, 2**i)) for i in range(2, 20)}
b = simple_benchmark.benchmark(
    [Series_astype, Series_apply, Series_tolist_map, Series_values_astype],
    arguments,
    argument_name=''Series size''
)

%matplotlib notebook
b.plot()

Tenga en cuenta que es un gráfico log-log debido a la amplia gama de tamaños que cubrí en el punto de referencia. Sin embargo, más bajo significa más rápido aquí.

Los resultados pueden ser diferentes para las diferentes versiones de Python / NumPy / Pandas. Así que si quieres compararlo, estas son mis versiones:

Versions
--------
Python 3.6.5
NumPy 1.14.2
Pandas 0.22.0

Answer 2

Actuación

Vale la pena ver el rendimiento real antes de comenzar cualquier investigación, ya que, contrariamente a la opinión popular, la list(map(str, x)) parece ser más lenta que x.apply(str) .

import pandas as pd, numpy as np

### Versions: Pandas 0.20.3, Numpy 1.13.1, Python 3.6.2 ###

x = pd.Series(np.random.randint(0, 100, 100000))

%timeit x.apply(str)          # 42ms   (1)
%timeit x.map(str)            # 42ms   (2)
%timeit x.astype(str)         # 559ms  (3)
%timeit [str(i) for i in x]   # 566ms  (4)
%timeit list(map(str, x))     # 536ms  (5)
%timeit x.values.astype(str)  # 25ms   (6)

Puntos a destacar:

1. (5) es ligeramente más rápido que (3) / (4), lo cual esperamos a medida que se mueva más trabajo a C [suponiendo que no se utilice la función lambda ].
2. (6) es, con mucho, el más rápido.
3. (1) / (2) son similares.
4. (3) / (4) son similares.

¿Por qué es rápido x.map / x.apply?

Esto parece ser porque usa el código Cython de compilación rápida:

cpdef ndarray[object] astype_str(ndarray arr):
    cdef:
        Py_ssize_t i, n = arr.size
        ndarray[object] result = np.empty(n, dtype=object)

    for i in range(n):
        # we can use the unsafe version because we know `result` is mutable
        # since it was created from `np.empty`
        util.set_value_at_unsafe(result, i, str(arr[i]))

    return result

¿Por qué x.astype (str) es lento?

Pandas aplica str a cada elemento de la serie, sin usar el Cython anterior.

Por lo tanto, el rendimiento es comparable a [str(i) for i in x] / list(map(str, x)) .

¿Por qué es tan rápido x.values.astype (str)?

Numpy no aplica una función en cada elemento de la matriz. Una descripción de esto encontré:

Si hizo s.values.astype(str) lo que obtiene es un objeto que contiene int . Este es el numpy realiza la conversión, mientras que los pandas iteran sobre cada elemento y llaman a str(item) en él. Entonces, si lo hace en un tipo de s.astype(str) , tiene un objeto que contiene str .

Hay una razón técnica por la que la versión numpy no se ha implementado en el caso de no nulos.