def prepare_data(exp_data, num_data):
x = np.arange(len(exp_data))
y = exp_data
exp_data = np.zeros((len(x), 2))
exp_data[:, 0] = x
exp_data[:, 1] = y
x = np.arange(len(num_data))
y = num_data
num_data = np.zeros((len(x), 2))
num_data[:, 0] = x
num_data[:, 1] = y
# quantify the difference between the two curves using PCM
pcm = 0 # similaritymeasures.pcm(exp_data, num_data)
# quantify the difference between the two curves using
# Discrete Frechet distance
df = 0 # similaritymeasures.frechet_dist(exp_data, num_data)
# quantify the difference between the two curves using
# area between two curves
area = 0 # similaritymeasures.area_between_two_curves(exp_data, num_data)
# quantify the difference between the two curves using
# Curve Length based similarity measure
cl = 0 # similaritymeasures.curve_length_measure(exp_data, num_data)
# quantify the difference between the two curves using
# Dynamic Time Warping distance
dtw, d = similaritymeasures.dtw(exp_data, num_data)
return pcm, df, area, cl, dtw, d
def similarity(sketch, other_sketch):
"""
sketch = sketchpad json output
other_sketch = saved json output from Django
"""
result = {}
if isinstance(sketch, dict) and isinstance(other_sketch, dict):
x, y = create_xy_coords('search', sketch)
P = np.array([x, y]).T
x1, y1 = create_xy_coords('other', other_sketch)
Q = np.array([x1, y1]).T
dh, ind1, ind2 = directed_hausdorff(P, Q)
df = similaritymeasures.frechet_dist(P, Q)
dtw, d = similaritymeasures.dtw(P, Q)
pcm = similaritymeasures.pcm(P, Q)
area = similaritymeasures.area_between_two_curves(P, Q)
cl = similaritymeasures.curve_length_measure(P, Q)
result = {
"dh": dh,
"df": df,
"dtw": dtw,
"pcw": pcm,
"cl": cl,
"area": area
}
return result
else:
return {"dh": 0}
def dynamic_time_warping_distance(series1, series2):
"""
Compute the Dynamic Time Warping distance between two series
Dynamic time warping is an algorithm used to measure similarity between
two sequences which may vary in time or speed.
It works as follows:
1. Divide the two series into equal points.
2. Calculate the euclidean distance between the first point in the
first series and every point in the second series. Store the minimum
distance calculated. (this is the ‘time warp’ stage)
3. Move to the second point and repeat 2. Move step by step along points
and repeat 2 till all points are exhausted.
4. Repeat 2 and 3 but with the second series as a reference point.
5. Add up all the minimum distances that were stored and this is a
true measure of similarity between the two series.
Args:
series1 (numpy.ndarray): First series
series2 (numpy.ndarray): Second series
Returns:
Dynamic time warping distance between the two series
"""
series1_2d = np.zeros((len(series1), 2))
series1_2d[:, 0] = range(len(series1))
series1_2d[:, 1] = series1
series2_2d = np.zeros((len(series2), 2))
series2_2d[:, 0] = range(len(series2))
series2_2d[:, 1] = series2
return similaritymeasures.dtw(series1_2d, series2_2d)[0]
def dtw_distance(ref_trj_l, pred_tr_l):
n_trj = len(pred_tr_l)
error = 0
for pred_tr, ref_trj in zip(pred_tr_l, ref_trj_l):
dtw_dist, d = similaritymeasures.dtw(ref_trj,pred_tr)
error+= dtw_dist
error_n = error/n_trj
return error_n
def dtw_compare(self, test_1_states: list, test_2_states: list):
""" The dtw function requires at least two dimensional inputs, for that 1d bins need a second axis that
represents time.
:param test_1_states: States for test one, at least 2 dimensions
:param test_2_states: States for test two, at least 2 dimensions
:return: Value of dtw
"""
import similaritymeasures
d_dtw, _ = similaritymeasures.dtw(test_1_states, test_2_states)
return d_dtw
def check_similarity(self, song1, option1, option2, sar=16000):
song1, sr1 = self.loadAudio(song1, sar)
opt1, sr2 = self.loadAudio(option1, sar)
opt2, sr3 = self.loadAudio(option2, sar)
x = range(0,5117)
song1 = [x, song1[-5117:]]
opt1 = [x, opt1[-5117:]]
opt2 = [x, opt2[-5117:]]
nsong1 = np.array(song1).T
nopt1 = np.array(opt1).T
nopt2 = np.array(opt2).T
print(np.shape(nopt1))
dtw1, d = similaritymeasures.dtw(opt1, song1)
dtw2, d = similaritymeasures.dtw(opt2, song1)
#print("DTW")
#print(dtw1, dtw2)
#dtw1, d = fastdtw(nopt1, nsong1, dist=euclidean)
#dtw2, d = fastdtw(nopt2, nsong1, dist=euclidean)
#print("fastDTW")
#print(dtw1, dtw2)
#dtw1 = similaritymeasures.frechet_dist(nopt1, nsong1)
#dtw2 = similaritymeasures.frechet_dist(nopt2, nsong1)
#print("fastDTW")
#print(dtw1, dtw2)
#dh1, _, _ = directed_hausdorff(nopt1, nsong1)
#dh2, _, _ = directed_hausdorff(nopt2, nsong1)
#print("Directed Hausdorff")
#print(dh1, dh2)
#dtw1 = similaritymeasures.pcm(nopt1, nsong1)
#dtw2 = similaritymeasures.pcm(nopt2, nsong1)
print(dtw1, dtw2)
return dtw1, dtw2
def shape_similarity_measures_all_to_all_unoptimized(data_dict: dict):
""" Calculates different predefined shape similarity measures from https://pypi.org/project/similaritymeasures/
Requires the roads to be saved as polylines
:param data_dict: Dict containing all the test data
:return: None
"""
import similaritymeasures
import time
start_time = time.time()
current_ops = 0
total_ops = len(data_dict)
print("In total", total_ops * total_ops, "comparison passes and",
total_ops,
"loop iterations will have to be completed for shape based input.")
for name1 in data_dict:
road1 = data_dict.get(name1)
road1_coords = road1.get(RoadDicConst.COORD_TUPLE_REP_ALLIGNED.value,
None)
if road1_coords is None:
add_coord_tuple_representation(data_dict=data_dict)
road1_coords = road1.get(
RoadDicConst.COORD_TUPLE_REP_ALLIGNED.value, None)
# TODO more
dicc_dtw = {}
dicc_dtw_opti = {}
dicc_frechet = {}
for name2 in data_dict:
# TODO optimize
road2 = data_dict.get(name2)
road2_coords = road2.get(
RoadDicConst.COORD_TUPLE_REP_ALLIGNED.value, None)
d_dtw, _ = similaritymeasures.dtw(road1_coords, road2_coords)
dicc_dtw[name2] = d_dtw
d_frechet = similaritymeasures.frechet_dist(
road1_coords, road2_coords)
dicc_frechet[name2] = d_frechet
road1[BehaviorDicConst.COORD_DTW_DIST.value] = dicc_dtw
road1[BehaviorDicConst.COORD_FRECHET_DIST.value] = dicc_frechet
current_ops += 1
print_remaining_time(start_time=start_time,
completed_operations=current_ops,
total_operations=total_ops)
def dtw_computation(self, gpx_data, gold):
### time difference of start to finish
delta_time = gpx_data[3][-1] - gpx_data[3][0]
### interpolate activity
gpx_data_interpolated = self.interpolate(gpx_data)
### compute dynamic time warping
dtw, d = similaritymeasures.dtw(gpx_data_interpolated, gold)
print("\nDTW (y): %2.5f" % (dtw))
print("T [s]: ", (delta_time))
return dtw, delta_time
def compare_frechet(self): x = np.arange(0, 10*np.pi, np.pi/10) s1 = np.cos(x) s2 = np.cos(x + np.pi/2) plt.plot(s1) plt.plot(s2) plt.show() s1 = np.array([x, s1]).T s2 = np.array([x, s2]).T dist,_ = similaritymeasures.dtw(s1, s2) print(dist)
def distance(ovitrap_eggs_i,lwO):
if(sys.argv[2]==RMSE):
return utils.rmse(ovitrap_eggs_i[ovitrap_eggs_i!=[None]], lwO[ovitrap_eggs_i!=[None]])
elif(sys.argv[2]==D):
return utils.D(ovitrap_eggs_i[ovitrap_eggs_i!=[None]], lwO[ovitrap_eggs_i!=[None]])
elif(sys.argv[2] in [FRECHET,DTW]):
ovitrap_eggs_i=np.array(ovitrap_eggs_i,dtype=np.float)#this change None for np.nan
valid_ovi_idx=~np.isnan(ovitrap_eggs_i)
reversed_valid_ovi_idx=valid_ovi_idx[::-1]
first,last=np.argmax(valid_ovi_idx), len(reversed_valid_ovi_idx)-np.argmax(reversed_valid_ovi_idx)-1
x=np.array([[time_range[idx],lwO[idx]] for idx in range(first,last)])
y=np.array([ [time_range[idx],ovitrap_eggs_i[idx] ] for idx,isValid in enumerate(valid_ovi_idx) if isValid])
if(sys.argv[2]==FRECHET): return sm.frechet_dist(x,y)
if(sys.argv[2]==DTW): return sm.dtw(x,y)[0]
else:
print('Metric %s not found'%sys.argv[2])
quit()
def get_best_blur(
evt_file,
numiter,
region_file,
blur_vals,
radius_100p,
binsize=0.2,
spectrum="core_flux_chart.dat",
out_root_common="core_psf",
):
xcen, ycen, ra, dec = get_centroids(evt_file, region_file)
print(xcen, ycen)
ecf_fractions = [
0.01,
0.025,
0.05,
0.075,
0.1,
0.2,
0.3,
0.4,
0.5,
0.6,
0.7,
0.8,
0.85,
0.9,
0.95,
0.99,
]
n_fractions = len(ecf_fractions)
ecf_profile_values = np.zeros((blur_vals.shape[0], n_fractions),
dtype=float)
ecf_radii_values = np.zeros((blur_vals.shape[0], n_fractions), dtype=float)
# generate the profile of the core
obs_ecf_file = "obs_ecf.fits"
ecf_calc.punlearn()
ecf_calc(
infile=evt_file,
outfile="obs_ecf.fits",
xpos=xcen,
ypos=ycen,
radius=radius_100p,
binsize=binsize,
clobber=True,
fraction=ecf_fractions,
)
for idx, blur in enumerate(blur_vals):
print(f"Blur={blur}")
outroot = out_root_common + "_blur_" + str(blur)
if not Path(outroot + "_projrays.fits").is_file():
print(f"Simulating PSF")
simulate_psf(
infile=evt_file,
outroot=outroot,
spectrum=spectrum,
numiter=numiter,
ra=ra,
dec=dec,
binsize=binsize,
blur=blur,
)
print("Generating the ecf profile")
out_ecf = generate_ecf_profile(
outroot + "_projrays.fits",
blur,
xcen,
ycen,
binsize=binsize,
ecf_fractions=ecf_fractions,
radius=radius_100p,
)
load_table(idx, out_ecf, colkeys=["r_mid", "fraction"])
ecf_profile = get_data(idx)
ecf_profile_values[idx, :] = ecf_profile.y
ecf_radii_values[idx, :] = ecf_profile.x
plt.plot(ecf_profile.x, ecf_profile.y, label=f"blur={blur}")
print("Done")
load_table(idx + 1, obs_ecf_file, colkeys=["r_mid", "fraction"])
obs_ecf = get_data(idx + 1)
plt.plot(obs_ecf.x,
obs_ecf.y,
label=f"Observation",
ls="--",
lw=2,
color="black")
plt.legend()
plt.xlabel("Radius (ACIS pixels)")
plt.ylabel("ECF")
plt.show()
dtw_vals = np.zeros(idx + 1)
pcm_vals = np.zeros(idx + 1)
clm_vals = pcm_vals.copy()
abtc_vals = pcm_vals.copy()
for i in range(idx + 1):
n1 = np.zeros((n_fractions, 2))
n2 = n1.copy()
n1[:, 0] = ecf_radii_values[i, :]
n2[:, 0] = obs_ecf.x
n1[:, 1] = ecf_profile_values[i, :]
n2[:, 1] = obs_ecf.y
dtw_vals[i], _ = similaritymeasures.dtw(n1, n2)
pcm_vals[i] = similaritymeasures.pcm(n1, n2)
clm_vals[i] = similaritymeasures.curve_length_measure(n1, n2)
abtc_vals[i] = similaritymeasures.area_between_two_curves(n1, n2)
print(f"Blur (Dynamic time warping) {blur_vals[np.argmin(dtw_vals)]}")
print(f"Blur (Partial Curve Mapping): {blur_vals[np.argmin(pcm_vals)]}")
print(f"Blur (Curve Length Measure): {blur_vals[np.argmin(clm_vals)]}")
print(f"Blur (Area Curve Measure): {blur_vals[np.argmin(abtc_vals)]}")
def test_c5_c6_dtw(self):
r, _ = similaritymeasures.dtw(curve5, curve6)
self.assertTrue(np.isclose(r, 9000.0))
def test_P_Q_dtw(self):
r, _ = similaritymeasures.dtw(P, Q)
self.assertTrue(r, 3.0)
def test_random_dtw(self):
r, d = similaritymeasures.dtw(curve_a_rand, curve_b_rand)
path = similaritymeasures.dtw_path(d)
c = cdist(curve_a_rand, curve_b_rand)
cost = np.sum(c[path[:, 0], path[:, 1]])
self.assertTrue(np.isclose(r, cost))
def test_P_Q_dtw_minkowski_p3(self):
r, _ = similaritymeasures.dtw(P, Q, metric='minkowski', p=3)
self.assertTrue(r, 3.0)
def main():
a = [(0.39, 0.8), (0.3, 0.45), (0.35, 0.78), (0.4, 0.3), (0.49, 0.8),
(0.51, 0.23), (0.6, 0.71)]
dtws_xy = []
dtws_aal = []
frechets_xy = []
frechets_aal = []
angles = range(0, 360, 30)
for i, angle in enumerate(angles):
b = rotate(a, angle)
dtw_xy, d_xy = dtw(a, b)
dtws_xy.append(dtw_xy)
fd_xy = frechet_dist(a, b)
frechets_xy.append(fd_xy)
# Convert the trajectories a and b to the trajectories in the AAL space.
aal_a, aal_b = to_aal([a, b])
dtw_aal, d_aal = dtw(aal_a, aal_b, metric=d_warp)
dtws_aal.append(dtw_aal)
fd_aal = frechet_dist(aal_a, aal_b)
frechets_aal.append(fd_aal)
a_angles, a_arc_lengths = zip(*aal_a)
b_angles, b_arc_lengths = zip(*aal_b)
f1 = plt.figure(1)
plt.subplot(4, 3, i + 1)
plt.plot(a_arc_lengths, a_angles, label="T")
plt.plot(b_arc_lengths, b_angles, label="Q")
plt.legend(prop={'size': 6})
plt.xlabel("Arc-length", fontsize=8)
plt.ylabel("Angle", fontsize=8)
plt.xticks(np.linspace(0, 1, num=5),
np.linspace(0, 1, num=5),
fontsize=8)
plt.yticks([-np.pi, 0, np.pi],
labels=[u"-\u03C0", "0", "\u03C0"],
fontsize=8)
plt.title("Angle={0:.1f} (rad)".format(np.radians(angle)), fontsize=8)
f1.tight_layout()
a_xs, a_ys = zip(*a)
b_xs, b_ys = zip(*b)
plt.figure(2)
plt.subplot(4, 3, i + 1, aspect='equal', adjustable='box')
plt.plot(a_xs, a_ys, label="T")
plt.plot(b_xs, b_ys, label="Q")
plt.xlabel("x", fontsize=8)
plt.ylabel("y", fontsize=8)
plt.title("Angle={0:.1f} (rad)".format(np.radians(angle)), fontsize=8)
plt.xticks(np.linspace(0, 1, num=3),
np.linspace(0, 1, num=3),
fontsize=8)
plt.yticks(np.linspace(0, 1, num=5),
np.linspace(0, 1, num=5),
fontsize=8)
plt.tight_layout()
angles = [np.radians(x) for x in angles]
plt.figure(3)
plt.plot(angles, dtws_xy, label="DTW")
plt.plot(angles, frechets_xy, label="Frechet")
plt.title("XY space")
plt.xlabel("Rotation Angle")
plt.ylabel("Distances")
plt.legend(prop={'size': 6})
plt.figure(4)
plt.plot(angles, dtws_aal, label="DTW")
plt.plot(angles, frechets_aal, label="Frechet")
plt.title("AAL space")
plt.xlabel("Rotation Angle")
plt.ylabel("Distances")
plt.legend(prop={'size': 6})
plt.show()
def stats_between_series(
xaxis_1: pandas.Series,
values_1: pandas.Series,
xaxis_2: pandas.Series,
values_2: pandas.Series,
print_: bool = False,
) -> dict:
"""Dynamic time warping and discret frechet distance for measuring similarity between two temporal sequences
Args:
xaxis_1 (pandas.Series): index axis of the dataframe 1
values_1 (pandas.Series): value axis of the dataframe 1
xaxis_2 (pandas.Series): index axis of the dataframe 2
values_2 (pandas.Series): value axis of the dataframe 2
Returns:
dict: `{"dtw": float, "frechet_dist": float}`
"""
dataframe_1 = pandas.merge(xaxis_1,
values_1,
right_index=True,
left_index=True)
dataframe_2 = pandas.merge(xaxis_2,
values_2,
right_index=True,
left_index=True)
dataframe_1.rename(columns={
xaxis_1.name: "id",
values_1.name: "values_1"
},
inplace=True)
dataframe_2.rename(columns={
xaxis_2.name: "id",
values_2.name: "values_2"
},
inplace=True)
dataframe_1.set_index("id", inplace=True)
dataframe_2.set_index("id", inplace=True)
unified = pandas.concat([dataframe_1, dataframe_2], axis=1)
unified["values_1"] = (pandas.to_numeric(
unified["values_1"], errors="coerce",
downcast="float").interpolate().fillna(method="bfill").fillna(
method="ffill"))
unified["values_2"] = (pandas.to_numeric(
unified["values_2"], errors="coerce",
downcast="float").interpolate().fillna(method="bfill").fillna(
method="ffill"))
xaxis_arranged = numpy.arange(len(unified))
dataframe_values_2 = numpy.array(
[xaxis_arranged, unified["values_2"].values])
dataframe_values_1 = numpy.array(
[xaxis_arranged, unified["values_1"].values])
dtw, d = similaritymeasures.dtw(dataframe_values_1, dataframe_values_2)
frechet_dist = similaritymeasures.frechet_dist(dataframe_values_1,
dataframe_values_2)
pcm = similaritymeasures.pcm(dataframe_values_1, dataframe_values_2)
area = similaritymeasures.area_between_two_curves(dataframe_values_1,
dataframe_values_2)
std = numpy.abs(
numpy.nanstd(dataframe_values_2[1]) -
numpy.nanstd(dataframe_values_1[1]))
if print_:
print(
{
"dtw": dtw,
"frechet_dist": frechet_dist,
"pcm": pcm,
"area": area,
"std": std,
},
dataframe_values_2,
)
return {
"dtw": dtw,
"frechet_dist": frechet_dist,
"pcm": pcm,
"area": area,
"std": std,
}
def test_P_Q_dtw_path(self):
r, d = similaritymeasures.dtw(P, Q)
path = similaritymeasures.dtw_path(d)
c = cdist(P, Q)
cost = sum(c[path[:, 0], path[:, 1]])
self.assertTrue(np.isclose(r, cost))
def main():
a = generate_sine_coords(7)
dtws_xy = []
dtws_aal = []
frechets_xy = []
frechets_aal = []
num_points = range(14, 7 * 20, 7)
for num in num_points:
b = generate_sine_coords(num)
dtw_xy, d_xy = dtw(a, b)
dtws_xy.append(dtw_xy)
fd_xy = frechet_dist(a, b)
frechets_xy.append(fd_xy)
# Convert the two curves, a and b, to the AAL space.
a_aal, b_aal = to_aal([a, b])
dtw_aal, d_aal = dtw(a_aal, b_aal, metric=d_warp)
dtws_aal.append(dtw_aal)
fd_aal = frechet_dist(a_aal, b_aal)
frechets_aal.append(fd_aal)
a_angles, a_arc_lengths = zip(*a_aal)
b_angles, b_arc_lengths = zip(*b_aal)
plt.figure(1)
plt.plot(a_arc_lengths, a_angles, label="a")
plt.plot(b_arc_lengths, b_angles, label="b")
plt.xlabel("Arc-length", fontsize=8)
plt.ylabel("Angle", fontsize=8)
plt.title("AAL Space", fontsize=8)
a_xs, a_ys = zip(*a)
b_xs, b_ys = zip(*b)
plt.figure(2)
plt.plot(a_xs, a_ys, label="a")
plt.plot(b_xs, b_ys, label="b")
plt.xlabel("z", fontsize=8)
plt.ylabel("y", fontsize=8)
plt.title("XY Space", fontsize=8)
num_points = list(num_points)
plt.figure(3)
plt.plot(num_points, dtws_xy, label="DTW")
plt.plot(num_points, frechets_xy, label="Frechet")
plt.xlabel("Number of nodes")
plt.ylabel("Distance")
plt.title("XY space")
plt.figure(4)
plt.plot(num_points, dtws_aal, label="DTW")
plt.plot(num_points, frechets_aal, label="Frechet")
plt.xlabel("Number of nodes")
plt.ylabel("Distance")
plt.title("AAL space")
plt.show()
# quantify the difference between the two curves using
# Discrete Frechet distance
df = similaritymeasures.frechet_dist(exp_data, num_data)
# quantify the difference between the two curves using
# area between two curves
area = similaritymeasures.area_between_two_curves(exp_data, num_data)
# quantify the difference between the two curves using
# Curve Length based similarity measure
cl = similaritymeasures.curve_length_measure(exp_data, num_data)
# quantify the difference between the two curves using
# Dynamic Time Warping distance
dtw, d = similaritymeasures.dtw(exp_data, num_data)
# print the results
print(pcm, df, area, cl, dtw)
# plot the data
fig = plt.figure()
ax1 = fig.add_subplot(111, projection='3d')
ax1.plot_wireframe(x, y, subz)
ax1.plot_wireframe(xx, yy, subzz, color='deeppink')
ax1.set_xlabel('x')
ax1.set_xlabel('y')
ax1.set_xlabel('z')
# plt.plot(exp_data[:, 0], exp_data[:, 1], exp_data[:, 2])
# quantify the difference between the two curves using
# Discrete Frechet distance
#df = similaritymeasures.frechet_dist(TwoDarrayLoop, tdArray)
# quantify the difference between the two curves using
# area between two curves
#area = similaritymeasures.area_between_two_curves(TwoDarrayLoop, tdArray)
# quantify the difference between the two curves using
# Curve Length based similarity measure
#cl = similaritymeasures.curve_length_measure(TwoDarrayLoop, tdArray)
# quantify the difference between the two curves using
# Dynamic Time Warping distance
dtw, d = similaritymeasures.dtw(TwoDarrayLoop, tdArray)
#print(pcm, '---', area, '---', cl, '---',dtw)
print('---', dtw)
#minX = np.min(TwoDarrayLoop[:, 0])
#plt.figure()
#plt.plot(TwoDarrayLoop[:, 0], TwoDarrayLoop[:, 1])
#plt.plot(tdArray[:, 0], tdArray[:, 1])
#plt.show()
#maxX = np.max(x)
#minY = np.min(y)
#maxY = np.max(y)
#xi = (x - minX) / (maxX - minX)
def dist_dtw(self, other):
dist_pos = similaritymeasures.dtw(self.cop_mlap.to_array().T,
other.cop_mlap.to_array().T)[0]
# print(f'{self} is {dist_pos:.2f} from {other}')
return dist_pos
Q = Q[::-1]
f_d, p_i, q_i = FrechetDist.frechetdist_index_2(P, Q)
print("frechet distance: ", f_d, p_i, q_i)
f_d, p_i, q_i = FrechetDist.frechetdist_index(P, Q)
print("frechet distance 2: ", f_d, p_i, q_i)
d = simm.frechet_dist(P, Q)
print("frechet distance: ", d)
distance = directed_hausdorff(P, Q)
print("hausdorff distance P-Q: ", distance)
distance = directed_hausdorff(Q, P)
print("hausdorff distance Q-P: ", distance)
px = [p[0] for p in P]
py = [p[1] for p in P]
qx = [p[0] for p in Q]
qy = [p[1] for p in Q]
plt.scatter(px+qx, py+qy)
plt.plot(px, py, label="P", color="red")
plt.plot(qx, qy, label="Q", color="blue")
plt.plot([px[p_i], qx[q_i]], [py[p_i], qy[q_i]], label="frechet dist", linestyle=":", color="purple")
plt.show()
df = simm.area_between_two_curves(P, Q)
print("area bt two curves: {}".format(df))
df = simm.dtw(P, Q)
print("dtw: {}".format(df))
df = simm.curve_length_measure(P, Q)
print("curve length: {}".format(df))
df = simm.pcm(P, Q)
print("pcm: {}".format(df))
def _compute_rec_score(predictions, trues, score_window, smooth_window, rec_error_type):
"""Compute an array of anomaly scores.
Args:
predictions (ndarray):
Predicted values.
trues (ndarray):
Ground truth.
score_window (int):
Size of the window over which the scores are calculated.
smooth_window (int):
Smooth window that will be applied to compute smooth errors.
rec_error_type (str):
Reconstruction error types.
Returns:
ndarray:
Array of anomaly scores.
"""
if (rec_error_type == "point"):
errors = [abs(y_h - y) for y_h, y in zip(predictions, trues)]
errors_smoothed = pd.Series(errors).rolling(
smooth_window, center=True, min_periods=smooth_window // 2).mean().values
z_scores = stats.zscore(errors_smoothed)
z_scores = np.clip(z_scores, a_min=0, a_max=None) + 1
elif (rec_error_type == "area"):
pd_true = pd.Series(np.asarray(trues).flatten())
pd_pred = pd.Series(np.asarray(predictions).flatten())
score_measure_true = pd_true.rolling(score_window, center=True,
min_periods=score_window // 2).apply(integrate.trapz)
score_measure_pred = pd_pred.rolling(score_window, center=True,
min_periods=score_window // 2).apply(integrate.trapz)
errors = abs(score_measure_true - score_measure_pred)
errors_smoothed = pd.Series(errors).rolling(smooth_window, center=True,
win_type='triang',
min_periods=smooth_window // 2).mean().values
z_scores = stats.zscore(errors_smoothed)
z_scores = np.clip(z_scores, a_min=0, a_max=None) + 1
elif (rec_error_type == "dtw"):
# DTW
i = 0
similarity_dtw = list()
length_dtw = (score_window // 2) * 2 + 1
hafl_length_dtw = length_dtw // 2
# add padding
true_pad = np.pad(trues, (hafl_length_dtw, hafl_length_dtw),
'constant', constant_values=(0, 0))
predictions_pad = np.pad(
predictions,
(hafl_length_dtw,
hafl_length_dtw),
'constant',
constant_values=(
0,
0))
while i < len(trues) - length_dtw:
true_data = np.zeros((length_dtw, 2))
true_data[:, 0] = np.arange(length_dtw)
true_data[:, 1] = true_pad[i:i + length_dtw]
preds_data = np.zeros((length_dtw, 2))
preds_data[:, 0] = np.arange(length_dtw)
preds_data[:, 1] = predictions_pad[i:i + length_dtw]
dtw, _ = sm.dtw(true_data, preds_data)
similarity_dtw = similarity_dtw + [dtw]
i += 1
similarity_dtw = [0] * int(length_dtw / 2) + similarity_dtw + [0] * (
len(trues) - len(similarity_dtw) - int(length_dtw / 2))
errors = similarity_dtw
errors_smoothed = pd.Series(errors).rolling(smooth_window, center=True,
min_periods=smooth_window // 2).mean().values
z_scores = stats.zscore(errors_smoothed)
z_scores = np.clip(z_scores, a_min=0, a_max=None) + 1
return z_scores
def test_c5_c6_dtw_path(self):
r, d = similaritymeasures.dtw(curve5, curve6)
path = similaritymeasures.dtw_path(d)
c = cdist(curve5, curve6)
cost = sum(c[path[:, 0], path[:, 1]])
self.assertTrue(np.isclose(r, cost))
def test_P_Q_dtw_cityblock(self):
r, _ = similaritymeasures.dtw(P, Q, metric='cityblock')
self.assertTrue(r, 3.0)
time_x = new_index/scale_factor
x = time_x.reshape((151,1))
#Carico la media della run#5 per Unemployement Rate
raw_media_run = np.loadtxt("media_run").astype("float64")
#Faccio uno slicing dei primi e un reshape
media_run = raw_media_run[:151].reshape((151,1))
topos = np.hstack((x,media_run))
Discrete_Frechet_distance = []
Dynamic_Time_Warping = []
start = time.time()
for a in range(1,78126): #78126
y = data[str(a)].to_numpy(np.float64).reshape((151,1))
cord_new = np.hstack((x,y))
Discrete_Frechet_distance.append(sm.frechet_dist(topos,cord_new))
dtw, _ = sm.dtw(topos, cord_new)
Dynamic_Time_Warping.append(dtw)
print("Column: " + str(a))
end = time.time()
print("Tempo di processamento: " + str(end - start))
Discrete_Frechet_distance_vector = np.array(Discrete_Frechet_distance)
np.savetxt('Discrete_Frechet_distance', Discrete_Frechet_distance_vector, delimiter=',')
Dynamic_Time_Warping_vector = np.array(Dynamic_Time_Warping)
np.savetxt('Dynamic_Time_Warping', Dynamic_Time_Warping_vector, delimiter=',')
