En R, estoy usando ccf o acf para calcular los pares de función de correlación cruzada para que yo pueda averiguar qué cambio me da el valor máximo. Desde el aspecto de la misma, R me da un normalizada de la secuencia de valores. Hay algo similar en Python, scipy o se supone que tengo que hacerlo con el fft módulo? Actualmente, estoy haciendo de la siguiente manera:

xcorr = lambda x,y : irfft(rfft(x)*rfft(y[::-1]))
x = numpy.array([0,0,1,1])
y = numpy.array([1,1,0,0])
print xcorr(x,y)
InformationsquelleAutor Legend | 2011-08-09

4 Comentarios

  1. 42

    A cruz-correlacionar 1d matrices de uso numpy.se correlacionan.

    2d de las matrices, el uso de scipy.de la señal.correlate2d.

    También hay scipy.stsci.de convolución.correlate2d.

    También hay matplotlib.pyplot.xcorr que se basa en numpy.se correlacionan.

    Ver este post en el SciPy lista de correo para algunos enlaces a diferentes implementaciones.

    Edit: @user333700 añadido un enlace a la SciPy billete para este problema en un comentario.

    • Las implementaciones vinculado de esta lista de correos de uso de la Fft para el seguro, tal vez ellos te ayudarán. También, no sé cuánto velocidad es un problema para el cartel.
    • np.correlacionar el no uso de la fft, y es sólo más rápido cuando la segunda serie/de la ventana es pequeña en relación a la primera. también hay scipy.de la señal.fftconvolve. véase también projects.scipy.org/numpy/ticket/1260
    • wow ahora tengo un montón de opciones para elegir 😀
    • Todos mailling lista de los enlaces están rotos!! ;-(
    • He actualizado el enlace a la SciPy boleto a punto para el archivo de internet, desde la página original parece haber desaparecido. Todos los otros enlaces (incluyendo la lista de correo de enlace) a trabajar para mí.
  2. 14

    Si usted está buscando una manera rápida, correlación cruzada normalizada en una o dos dimensiones
    Yo recomendaría la biblioteca openCV (ver http://opencv.willowgarage.com/wiki/ http://opencv.org/). La correlación cruzada de código mantenida por este grupo es el que más rápido va a encontrar, y será normalizado (resultados entre -1 y 1).

    Mientras que esta es una biblioteca de C++ el código se mantiene con CMake y tiene enlaces python para que el acceso a la cruz funciones de correlación es conveniente. OpenCV también juega muy bien con numpy. Si me quiere calcular el 2-D de correlación cruzada a partir de arrays de numpy yo podría hacerlo de la siguiente manera.

    import numpy
    import cv
    
    #Create a random template and place it in a larger image
    templateNp = numpy.random.random( (100,100) )
    image = numpy.random.random( (400,400) )
    image[:100, :100] = templateNp
    
    #create a numpy array for storing result
    resultNp = numpy.zeros( (301, 301) )
    
    #convert from numpy format to openCV format
    templateCv = cv.fromarray(numpy.float32(template))
    imageCv = cv.fromarray(numpy.float32(image))
    resultCv =  cv.fromarray(numpy.float32(resultNp))
    
    #perform cross correlation
    cv.MatchTemplate(templateCv, imageCv, resultCv, cv.CV_TM_CCORR_NORMED)
    
    #convert result back to numpy array
    resultNp = np.asarray(resultCv)

    Por sólo un 1-D de correlación cruzada de crear una 2-D de la matriz con forma igual a (N, 1 ). A pesar de que existe algo más de código para convertir a un openCV formato de la velocidad sobre scipy es bastante impresionante.

    • FYI también puede hacer esto con scikit-imagen si no quieres usar OpenCV. Consulte este ejemplo.
  3. 11

    Acabo de terminar de escribir mi propio optimizado la aplicación de la normalización de correlación cruzada para arreglos de N-dimensiones. Usted puede conseguir a partir de aquí.

    Se calculará de correlación cruzada, ya sea directamente, mediante scipy.ndimage.correlate, o en el dominio de la frecuencia, utilizando scipy.fftpack.fftn/ifftn dependiendo de lo que va a ser más rápida.

  4. 2

    Para 1D array, numpy.correlate es más rápido que scipy.signal.correlate, en diferentes tamaños, veo una constante de 5x rendimiento de la ganancia mediante numpy.correlate. Cuando dos matrices son de tamaño similar (la brillante línea de conexión de la diagonal), la diferencia de rendimiento es aún más excepcional (50x +).

    # a simple benchmark
    res = []
    for x in range(1, 1000):
        list_x = []
        for y in range(1, 1000): 
    
            # generate different sizes of series to compare
            l1 = np.random.choice(range(1, 100), size=x)
            l2 = np.random.choice(range(1, 100), size=y)
    
            time_start = datetime.now()
            np.correlate(a=l1, v=l2)
            t_np = datetime.now() - time_start
    
            time_start = datetime.now()
            scipy.signal.correlate(in1=l1, in2=l2)
            t_scipy = datetime.now() - time_start
    
            list_x.append(t_scipy / t_np)
        res.append(list_x)
    plt.imshow(np.matrix(res))

    Computación en la función de correlación cruzada?

    Como predeterminado, scipy.de la señal.se correlacionan calcula un extra de unos pocos números de relleno y que podría explicarse la diferencia de rendimiento.

    >> l1 = [1,2,3,2,1,2,3]
    >> l2 = [1,2,3]
    >> print(numpy.correlate(a=l1, v=l2))
    >> print(scipy.signal.correlate(in1=l1, in2=l2))
    
    [14 14 10 10 14]
    [ 3  8 14 14 10 10 14  8  3]  # the first 3 is [0,0,1]dot[1,2,3]

Dejar respuesta

Please enter your comment!
Please enter your name here