dtaidistance
v2.3.10
Pustaka untuk jarak deret waktu (misalnya Dynamic Time Warping) yang digunakan di Kelompok Riset DTAI. Pustaka menawarkan implementasi Python murni dan implementasi cepat di C. Implementasi C hanya memiliki Cython sebagai ketergantungan. Ini kompatibel dengan Numpy dan Pandas dan diimplementasikan sedemikian rupa sehingga operasi penyalinan data yang tidak perlu dapat dihindari.
Dokumentasi: http://dtaidistance.readthedocs.io
Contoh:
from dtaidistance import dtw
import numpy as np
s1 = np.array([0.0, 0, 1, 2, 1, 0, 1, 0, 0])
s2 = np.array([0.0, 1, 2, 0, 0, 0, 0, 0, 0])
d = dtw.distance_fast(s1, s2)
Mengutip karya ini:
Wannes Meert, Kilian Hendrickx, Toon Van Craenendonck, Pieter Robberechts, Hendrik Blockeel & Jesse Davis.
Jarak DTAID (Versi v2). Zenodo.
http://doi.org/10.5281/zenodo.5901139
Baru di v2 :
ssize_t yang konsisten daripada int memungkinkan struktur data yang lebih besar pada mesin 64 bit dan lebih kompatibel dengan Numpy.max_dist ternyata mirip dengan karya Silva dan Batista pada PrunedDTW [7]. Toolbox sekarang mengimplementasikan versi yang sama dengan PrunedDTW karena memangkas lebih banyak jarak parsial. Selain itu, argumen use_pruning ditambahkan untuk secara otomatis menyetel max_dist ke jarak Euclidean, seperti yang disarankan oleh Silva dan Batista, untuk mempercepat komputasi (tersedia metode baru ub_euclidean ).dtaidistance.dtw_ndim . $ pip install dtaidistance
atau
$ conda install -c conda-forge dtaidistance
Instalasi pip memerlukan Numpy sebagai dependensi untuk mengkompilasi kode C yang kompatibel dengan Numpy (menggunakan Cython). Namun, ketergantungan ini bersifat opsional dan dapat dihilangkan.
Kode sumber tersedia di github.com/wannesm/dtaidistance.
Jika Anda mengalami masalah selama kompilasi (misalnya implementasi berbasis C atau OpenMP tidak tersedia), lihat dokumentasi untuk opsi lebih lanjut.
from dtaidistance import dtw
from dtaidistance import dtw_visualisation as dtwvis
import numpy as np
s1 = np.array([0., 0, 1, 2, 1, 0, 1, 0, 0, 2, 1, 0, 0])
s2 = np.array([0., 1, 2, 3, 1, 0, 0, 0, 2, 1, 0, 0, 0])
path = dtw.warping_path(s1, s2)
dtwvis.plot_warping(s1, s2, path, filename="warp.png")
Hanya jarak yang diukur berdasarkan dua urutan angka:
from dtaidistance import dtw
s1 = [0, 0, 1, 2, 1, 0, 1, 0, 0]
s2 = [0, 1, 2, 0, 0, 0, 0, 0, 0]
distance = dtw.distance(s1, s2)
print(distance)
Versi tercepat (30-300 kali) menggunakan c secara langsung tetapi memerlukan array sebagai input (dengan tipe ganda), dan (opsional) juga memangkas perhitungan dengan mengatur max_dist ke batas atas Euclidean:
from dtaidistance import dtw
import array
s1 = array.array('d',[0, 0, 1, 2, 1, 0, 1, 0, 0])
s2 = array.array('d',[0, 1, 2, 0, 0, 0, 0, 0, 0])
d = dtw.distance_fast(s1, s2, use_pruning=True)
Atau Anda bisa menggunakan array numpy (dengan dtype double atau float):
from dtaidistance import dtw
import numpy as np
s1 = np.array([0, 0, 1, 2, 1, 0, 1, 0, 0], dtype=np.double)
s2 = np.array([0.0, 1, 2, 0, 0, 0, 0, 0, 0])
d = dtw.distance_fast(s1, s2, use_pruning=True)
Periksa __doc__ untuk informasi tentang argumen yang tersedia:
print(dtw.distance.__doc__)
Sejumlah opsi diperkirakan dapat menghentikan lebih awal beberapa jalur yang sedang dieksplorasi oleh algoritma pemrograman dinamis atau menyesuaikan perhitungan ukuran jarak:
window : Hanya izinkan pergeseran sejauh ini dari dua diagonal.max_dist : Berhenti jika ukuran jarak yang dikembalikan lebih besar dari nilai ini.max_step : Jangan izinkan langkah lebih besar dari nilai ini.max_length_diff : Mengembalikan tak terhingga jika perbedaan panjang dua rangkaian lebih besar.penalty : Penalti yang ditambahkan jika kompresi atau ekspansi diterapkan (di atas jarak).psi : Relaksasi Psi untuk mengabaikan awal dan/atau akhir rangkaian (untuk rangkaian siklik) [2].use_pruning : Pangkas perhitungan berdasarkan batas atas Euclidean. Jika, di samping jarak, Anda juga ingin matriks lengkap melihat semua kemungkinan jalur pelengkungan:
from dtaidistance import dtw
s1 = [0, 0, 1, 2, 1, 0, 1, 0, 0]
s2 = [0, 1, 2, 0, 0, 0, 0, 0, 0]
distance, paths = dtw.warping_paths(s1, s2)
print(distance)
print(paths)
Matriks dengan semua jalur warping dapat divisualisasikan sebagai berikut:
from dtaidistance import dtw
from dtaidistance import dtw_visualisation as dtwvis
import random
import numpy as np
x = np.arange(0, 20, .5)
s1 = np.sin(x)
s2 = np.sin(x - 1)
random.seed(1)
for idx in range(len(s2)):
if random.random() < 0.05:
s2[idx] += (random.random() - 0.5) / 2
d, paths = dtw.warping_paths(s1, s2, window=25, psi=2)
best_path = dtw.best_path(paths)
dtwvis.plot_warpingpaths(s1, s2, paths, best_path)
Perhatikan parameter psi yang melonggarkan pencocokan di awal dan akhir. Dalam contoh ini hasilnya adalah kecocokan sempurna meskipun gelombang sinusnya sedikit bergeser.
Untuk menghitung ukuran jarak DTW antara semua barisan dalam daftar barisan, gunakan metode dtw.distance_matrix . Anda dapat mengatur variabel untuk menggunakan lebih banyak atau lebih sedikit kode c ( use_c dan use_nogil ) dan eksekusi paralel atau serial ( parallel ).
Metode distance_matrix mengharapkan daftar daftar/array:
from dtaidistance import dtw
import numpy as np
series = [
np.array([0, 0, 1, 2, 1, 0, 1, 0, 0], dtype=np.double),
np.array([0.0, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0]),
np.array([0.0, 0, 1, 2, 1, 0, 0, 0])]
ds = dtw.distance_matrix_fast(series)
atau matriks (jika semua deret mempunyai panjang yang sama):
from dtaidistance import dtw
import numpy as np
series = np.matrix([
[0.0, 0, 1, 2, 1, 0, 1, 0, 0],
[0.0, 1, 2, 0, 0, 0, 0, 0, 0],
[0.0, 0, 1, 2, 1, 0, 0, 0, 0]])
ds = dtw.distance_matrix_fast(series)
Anda dapat menginstruksikan penghitungan untuk hanya mengisi sebagian matriks ukuran jarak. Misalnya untuk mendistribusikan komputasi ke beberapa node, atau hanya membandingkan seri sumber dengan seri target.
from dtaidistance import dtw
import numpy as np
series = np.matrix([
[0., 0, 1, 2, 1, 0, 1, 0, 0],
[0., 1, 2, 0, 0, 0, 0, 0, 0],
[1., 2, 0, 0, 0, 0, 0, 1, 1],
[0., 0, 1, 2, 1, 0, 1, 0, 0],
[0., 1, 2, 0, 0, 0, 0, 0, 0],
[1., 2, 0, 0, 0, 0, 0, 1, 1]])
ds = dtw.distance_matrix_fast(series, block=((1, 4), (3, 5)))
Output dalam hal ini adalah:
# 0 1 2 3 4 5
[[ inf inf inf inf inf inf] # 0
[ inf inf inf 1.4142 0.0000 inf] # 1
[ inf inf inf 2.2360 1.7320 inf] # 2
[ inf inf inf inf 1.4142 inf] # 3
[ inf inf inf inf inf inf] # 4
[ inf inf inf inf inf inf]] # 5
Matriks jarak dapat digunakan untuk pengelompokan deret waktu. Anda dapat menggunakan metode yang ada seperti scipy.cluster.hierarchy.linkage atau salah satu dari dua metode pengelompokan yang disertakan (yang terakhir adalah pembungkus untuk metode tautan SciPy).
from dtaidistance import clustering
# Custom Hierarchical clustering
model1 = clustering.Hierarchical(dtw.distance_matrix_fast, {})
cluster_idx = model1.fit(series)
# Augment Hierarchical object to keep track of the full tree
model2 = clustering.HierarchicalTree(model1)
cluster_idx = model2.fit(series)
# SciPy linkage clustering
model3 = clustering.LinkageTree(dtw.distance_matrix_fast, {})
cluster_idx = model3.fit(series)
Untuk model yang melacak pohon pengelompokan penuh ( HierarchicalTree atau LinkageTree ), pohon tersebut dapat divisualisasikan:
model.plot("myplot.png")
Opsional:
Perkembangan:
DTAI distance code.
Copyright 2016-2022 KU Leuven, DTAI Research Group
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
