def load_data(self):
"""
Prepare numpy array X with shape (num_instances, img_size, img_size, num_variables)
and y with shape (num_instances, num_variables)
"""
X, Y = np.empty((self.num_instances, self.img_size, self.img_size, self.num_variables)), \
np.empty((self.num_instances, self.num_variables))
print(X.shape)
# Initialize PAA transformer
paa = PiecewiseAggregateApproximation(window_size=None,
output_size=self.img_size,
overlapping=False)
rp = RecurrencePlot()
# For all instance
start = time.time()
for idx, row in enumerate(self.data.iterrows()):
for i in range(self.num_variables):
# Get current variable's series
# Apply linear interpolation on missing values
s = row[1][i].interpolate(
limit_direction='both').to_numpy()[:self.ts_length]
# Apply PAA and RP
X[idx, :, :, i] = rp.transform(
paa.transform(np.expand_dims(s[:-1], axis=0)))[0]
Y[idx, i] = s[-1]
end = time.time()
print(f"Data loaded in {end - start} seconds")
return X, Y
def encode_dataset(dataset,
batch_size,
downscale_factor,
pooling_function,
dimension=1,
time_delay=1,
threshold=None):
""" Computation of encodings has to be done in batches due to the large size of the dataset.
Otherwise the kernel will die!
For downscaling pick np.mean (average pooling) or np.max (max pooling) respectively.
If downscaling is not required choose downscale_factor=1.
Keep in mind the network expects an input image size of 64x64.
The function returns a 3D matrix.
The new 3D matrix contains several 2D matrices, which correspond to the time series encodings/images.
The order of the objects does not change, which means for example that the 23rd slice of the
input dataset corresponds to the 23rd encoding in the 3D Matrix."""
n, l = np.shape(dataset)
f = downscale_factor
n_batches = n // batch_size
batches = np.linspace(1, n_batches, n_batches, dtype=int) * batch_size
rp = RecurrencePlot(dimension=dimension,
time_delay=time_delay,
threshold=threshold)
print('Encoding started...')
for p in range(n_batches):
if p == 0:
X_rp = rp.transform(dataset[0:batches[p], :])
sample = block_reduce(X_rp[0],
block_size=(f, f),
func=pooling_function)
l_red = sample.shape[0]
X_rp_red = np.zeros((n, l_red, l_red))
print('output 3D Matrix shape: ', np.shape(X_rp_red))
j = 0
for i in range(0, batches[p]):
X_rp_red[i] = block_reduce(X_rp[j],
block_size=(f, f),
func=pooling_function)
j += 1
else:
X_rp = rp.transform(X[batches[p - 1]:batches[p], :])
j = 0
for i in range(batches[p - 1], batches[p]):
X_rp_red[i] = block_reduce(X_rp[j],
block_size=(f, f),
func=pooling_function)
j += 1
print('Encoding successful!')
print('#####################################')
return X_rp_red
def rri_test_recurrent(filelist=None):
global shape_tmp
for i in range(len(filelist)):
# for i in range(10):
with open(filelist[i], 'rb') as f:
plk_tmp = pkl.load(f)
ecg_re = ecg.ecg(signal=plk_tmp, sampling_rate=Fs, show=False)
rpeaks_tmp = ecg_re['rpeaks'].tolist()
nni = tools.nn_intervals(rpeaks=rpeaks_tmp)
nni_tmp = nni.reshape((-1, int(nni.shape[0]))) # for 2d data type
rp = RecurrencePlot(threshold='point', percentage=20)
X_rp = rp.fit_transform(nni_tmp)
dst = cv2.resize(X_rp[0],
dsize=(135, 135),
interpolation=cv2.INTER_AREA)
shape_tmp.append(X_rp.shape)
recurrence_tmp.append(X_rp)
recur_resize.append(dst)
# for pandas
# shape_tmp = shape_tmp.append(pd.DataFrame(X_rp.shape))
# plot check
plt.imshow(X_rp[0], cmap='binary', origin='lower')
plt.plot(nni)
plt.title('Recurrence Plot', fontsize=16)
plt.tight_layout()
plt.show()
# np_tmp = np.column_stack([np_tmp, X_rp])
if i == 0:
pass
return shape_tmp, recurrence_tmp, np.asarray(recur_resize)
def save_recurrencePlots(net, save_recurrencePlots_file):
global save_recurrence_plots
if save_recurrence_plots:
for name, parameters in net.named_parameters():
if "fc" in name and parameters.cpu().detach().numpy().ndim == 2:
hiddenState = parameters.cpu().detach().numpy()
rp = RecurrencePlot()
X_rp = rp.fit_transform(hiddenState)
plt.figure(figsize=(6, 6))
plt.imshow(X_rp[0], cmap='binary', origin='lower')
plt.savefig(save_recurrencePlots_file, dpi=600)
else:
continue
else:
pass
def ts_imaging(self, data):
"""
Calcultes the image representation for each batch
Args:
data (tf.tensor(batch_size, sequence_length)): a batch of the aggregate power sequences
Raises:
ImagingMethodError: Error raised in case a wrong image transform is provided
Returns:
tensor(batch_size, img_size, img_size, 1): the image representation of the of the input data
"""
if self.img_method == 'gasf':
transformer = GramianAngularField(image_size=self.img_size,
method='summation')
tsi = transformer.fit_transform(data)
elif self.img_method == 'gadf':
transformer = GramianAngularField(image_size=self.img_size,
method='difference')
tsi = transformer.fit_transform(data)
elif self.img_method == 'mtf':
transformer = MarkovTransitionField(image_size=self.img_size)
tsi = transformer.fit_transform(data)
elif self.img_method == 'rp':
transformer = RecurrencePlot(threshold='point', percentage=20)
tsi = transformer.fit_transform(data)
elif self.img_size == 'all':
print("""
To use the three images at once
the input layer need to be adapted in (line 197 in IM2Seq.py).
The new input layer should be :
model.add(Conv2D(filters=8, kernel_size=4, strides=2, activation='linear',
input_shape=(self.img_size, self.img_size, 3)))
""")
RP = RecurrencePlot(threshold='point',
percentage=20).fit_transform(data)
GASF = GramianAngularField(image_size=self.img_size,
method='summation').fit_transform(data)
MTF = MarkovTransitionField(
image_size=self.img_size).fit_transform(data)
tsi = np.stack([RP, GASF, MTF], axis=3)
else:
raise ImagingMethodError()
return tsi
def evaluate_classifiers(dst):
print("[%s] Processing dataset %s" % (datetime.now().strftime("%F %T"), dst))
train_x, train_y = load_from_tsfile_to_dataframe(os.path.join(UCR_DATASET_PATH, dst, dst + "_TRAIN.ts"))
test_x, test_y = load_from_tsfile_to_dataframe(os.path.join(UCR_DATASET_PATH, dst, dst + "_TEST.ts"))
data_train = [train_x.iloc[i][0] for i in range(train_x.shape[0])]
data_test = [test_x.iloc[i][0] for i in range(test_x.shape[0])]
enc = LabelEncoder().fit(train_y)
ohe = OneHotEncoder(sparse=False)
labels_encoded = enc.transform(train_y)
integer_encoded = labels_encoded.reshape(len(labels_encoded), 1)
labels_train = ohe.fit_transform(integer_encoded)
ts_plotters = [RecurrencePlot(threshold='point', percentage=20),
MarkovTransitionField(),
GramianAngularField()]
def evaluate_classifier(plot_obj):
try:
classifier = classif_class(input_dim, num_classes=len(set(train_y)),
batch_size=batch_size, series_plot_obj=plot_obj)
classifier.train(data_train, labels_train, n_epochs=n_epochs)
y_pred = [classifier.predict(series) for series in data_test]
y_pred = enc.inverse_transform(y_pred)
accuracy = accuracy_score(test_y, y_pred)
f1 = f1_score(test_y, y_pred, average='macro')
with open("tsplot_results.csv", "a") as f:
f.write("{};{};{};{};{}\n".format(classif_class.__class__.__name__, plot_obj.__class__.__name__, dst, accuracy, f1))
return accuracy, f1
except Exception as e:
print("Exception while evaluating classifier:", e.__str__())
return float('nan'), float('nan')
return list(itertools.chain(*[evaluate_classifier(plot_obj) for plot_obj in ts_plotters]))
class TSToRP(Transform):
r"""Transforms a time series batch to a 4d TSImage (bs, n_vars, size, size) by applying Recurrence Plot.
It requires input to be previously normalized between -1 and 1"""
order = 98
def __init__(self, size=224, cmap=None, **kwargs):
self.size, self.cmap = size, cmap
self.encoder = RecurrencePlot(**kwargs)
def encodes(self, o: TSTensor):
bs, *_, seq_len = o.shape
size = ifnone(self.size, seq_len)
if size != seq_len:
o = F.interpolate(o.reshape(-1, 1, seq_len),
size=size,
mode='linear',
align_corners=False)[:, 0]
else:
o = o.reshape(-1, seq_len)
output = self.encoder.fit_transform(o.cpu().numpy()) / 2
output = output.reshape(bs, -1, size, size)
if self.cmap and output.shape[1] == 1:
output = TSImage(plt.get_cmap(
self.cmap)(output)[..., :3]).squeeze(1).permute(0, 3, 1, 2)
else:
output = TSImage(output)
return output.to(device=o.device)
def __init__(self, input_dim, num_classes, batch_size=16, series_plot_obj=None):
self.input_dim = input_dim
self.batch_size = batch_size
self.num_classes = num_classes
self.series_plot_obj = series_plot_obj
if self.series_plot_obj is None:
self.series_plot_obj = RecurrencePlot(threshold='point', percentage=20)
self.init_model()
def test_actual_results_single_value(params):
"""Test that the actual results are the expected ones."""
arr_actual = JointRecurrencePlot(**params).transform(X)
arr_desired = []
for i in range(n_features):
arr_desired.append(RecurrencePlot(**params).transform(X[:, i]))
arr_desired = np.prod(arr_desired, axis=0)
np.testing.assert_allclose(arr_actual, arr_desired, atol=1e-5, rtol=0.)
def mrp_encode_3_to_4(arr_3d, percentage=60, swap=(2, 2)):
transformer_multi = MultivariateTransformer(RecurrencePlot(
threshold='point', percentage=percentage),
flatten=False)
recplot_isff_4d = (transformer_multi.fit_transform(
array.swapaxes(swap[0], swap[1])) for array in arr_3d)
return recplot_isff_4d
def toRPdata(tsdatas,
dimension=1,
time_delay=1,
threshold=None,
percentage=10,
flatten=False):
X = []
rp = RecurrencePlot(dimension=dimension,
time_delay=time_delay,
threshold=threshold,
percentage=percentage,
flatten=flatten)
for data in tsdatas:
data_rp = rp.fit_transform(data)
X.append(data_rp[0])
return np.array(X)
def test_actual_results_without_flatten():
"""Test that the actual results are the expected ones."""
params = {'estimator': RecurrencePlot(dimension=6), 'flatten': False}
arr_actual = MultivariateTransformer(**params).fit_transform(X)
arr_desired = []
for i in range(n_features):
arr_desired.append(params['estimator'].transform(X[:, i]))
arr_desired = np.transpose(arr_desired, axes=(1, 0, 2, 3))
np.testing.assert_allclose(arr_actual, arr_desired, atol=1e-5, rtol=0.)
def __init__(self, series, labels, img_size=128, batch_size=32, series_plot_obj=None):
self.series = series
self.labels = labels
self.img_dim = img_size
self.batch_size = batch_size
self.indexes = np.arange(len(self.series))
self.rp = series_plot_obj
if self.rp is None:
self.rp = RecurrencePlot(threshold='point', percentage=20)
def test_actual_results_with_flatten():
"""Test that the actual results are the expected ones."""
params = {'estimator': RecurrencePlot(dimension=6), 'flatten': True}
arr_actual = MultivariateTransformer(**params).fit_transform(X)
arr_desired = []
for i in range(n_features):
arr_desired.append(params['estimator'].transform(X[:, i]).reshape(
(n_samples, -1)))
arr_desired = np.concatenate(arr_desired, axis=1)
np.testing.assert_allclose(arr_actual, arr_desired, atol=1e-5, rtol=0.)
def RP_encoder(ts,
size=None,
dimension=1,
time_delay=1,
threshold=None,
percentage=10,
norm_output=True,
**kwargs):
ts = To2dArray(ts)
assert ts.ndim == 2, 'ts ndim must be 2!'
if size is None: size = ts.shape[-1]
else: size = min(size, ts.shape[-1])
ts = PAA(window_size=None, output_size=size).fit_transform(ts)
encoder = RP(dimension=dimension,
time_delay=time_delay,
threshold=threshold,
percentage=percentage)
output = np.squeeze(encoder.fit_transform(ts), 0)
if norm_output: return norm(output)
else: return output
def rp_transform(data, image_size=500, show=False, img_index=0):
# RP transformationmtf
transform = RecurrencePlot(dimension=1,
threshold='percentage_points',
percentage=30)
return (pyts_transform(transform,
data,
image_size=image_size,
show=show,
cmap='binary',
img_index=img_index))
def test_actual_results_lists(params):
"""Test that the actual results are the expected ones."""
arr_actual = JointRecurrencePlot(**params).transform(X)
arr_desired = []
for i, (threshold, percentage) in enumerate(
zip(params['threshold'], params['percentage'])):
arr_desired.append(
RecurrencePlot(threshold=threshold,
percentage=percentage).transform(X[:, i]))
arr_desired = np.prod(arr_desired, axis=0)
np.testing.assert_allclose(arr_actual, arr_desired, atol=1e-5, rtol=0.)
def ts_imaging(self, data):
"""
Calcultes the image representation for each batch
Args:
data (tf.tensor(batch_size, sequence_length)): a batch of the aggregate power sequences
Raises:
ImagingMethodError: Error raised in case a wrong image transform is provided
Returns:
tensor(batch_size, img_size, img_size, 1): the image representation of the of the input data
"""
if self.img_method == 'gasf':
transformer = GramianAngularField(image_size=self.img_size,
method='summation')
tsi = transformer.fit_transform(data)
elif self.img_method == 'gadf':
transformer = GramianAngularField(image_size=self.img_size,
method='difference')
tsi = transformer.fit_transform(data)
elif self.img_method == 'mtf':
transformer = MarkovTransitionField(image_size=self.img_size)
tsi = transformer.fit_transform(data)
elif self.img_method == 'rp':
transformer = RecurrencePlot(threshold='point', percentage=20)
tsi = transformer.fit_transform(data)
elif self.img_size == 'all':
RP = RecurrencePlot(threshold='point',
percentage=20).fit_transform(data)
GASF = GramianAngularField(image_size=self.img_size,
method='summation').fit_transform(data)
MTF = MarkovTransitionField(
image_size=self.img_size).fit_transform(data)
tsi = np.stack([RP, GASF, MTF], axis=3)
else:
raise ImagingMethodError()
return tsi
def seq_to_rp(self, X):
X_rp = np.empty((len(X), *self.input_shape))
for i, x in enumerate(X):
img = RecurrencePlot(**self.rp_params).fit_transform([x])[0]
img = cv2.resize(img,
dsize=self.input_shape[:2],
interpolation=cv2.INTER_CUBIC).astype(
self.data_type)
if np.sum(img) > 0:
# TODO: improve fit/predict statistics
# Normalizar
if self.normalize:
img = (img - img.min()) / (img.max() - img.min()
) # MinMax (0,1)
#img = (img - img.mean()) / np.max([img.std(), 1e-4])
# # centralizar
# if centralizar:
# img -= img.mean()
# Padronizar
elif self.standardize:
img = (img - img.mean()) / img.std(
) #tf.image.per_image_standardization(img).numpy()
elif self.rescale:
img = (img - img.min()) / (img.max() - img.min())
# N canais
img = np.stack([img for i in range(self.input_shape[-1])],
axis=-1).astype(self.data_type)
X_rp[i, ] = img
return X_rp
def create_rp(segment,
dimension=2, time_delay=1, percentage=1, use_clip=False, knn=None, imsize=None,
images_dir='', base_name='Sample',
suffix='jpg', # suffix='png'
show_image=False, cmap=None, ##cmap='gray', cmap='binary'
):
"""Generate recurrence plot for specified signal segment and save to disk"""
if base_name is None:
base_name = 'sample'
fname = '{}_d{}_t{}_p{}{}.{}'.format(base_name, dimension, time_delay, percentage,
'_clipped' if use_clip else '', suffix)
segment = np.expand_dims(segment, 0)
if knn is not None:
rp = RecurrencePlot(dimension=dimension, time_delay=time_delay)
X_dist = rp.fit_transform(segment)[0]
X_rp = mask_knn(X_dist, k=knn, policy='cols')
elif use_clip:
rp = RecurrencePlot(dimension=dimension, time_delay=time_delay)
X_dist = rp.fit_transform(segment)
X_rp = rp_norm(X_dist, threshold='percentage_clipped', percentage=percentage)[0]
else:
rp = RecurrencePlot(dimension=dimension, time_delay=time_delay,
#threshold='percentage_points', percentage=percentage)
threshold='point', percentage=percentage)
X_rp = rp.fit_transform(segment)[0]
if imsize is not None:
X_rp = resize_rp(X_rp, new_shape=imsize, use_max=True)
imageio.imwrite(os.path.join(images_dir, fname), np_to_uint8(X_rp))
if show_image:
plt.figure(figsize=(3, 3))
plt.imshow(X_rp, cmap=cmap, origin='lower')
plt.title('Recurrence Plot for {}'.format(fname), fontsize=14)
plt.show()
return fname
def generate_rp(frame, dimension, threshold, percentage, file_name, count):
data_rp = []
data_rp.append(frame.values.reshape(1, -1))
data_rp.append(frame.values.reshape(1, -1))
data_rp = np.asarray(data_rp)
# Recurrence plot transformation
#X_rp1 = RecurrencePlot(dimension=3, time_delay=1,threshold=None, percentage=0).fit_transform(data_rp[0])[0]
X_rp1 = RecurrencePlot(dimension=dimension,
time_delay=1,
threshold=threshold,
percentage=percentage).fit_transform(data_rp[0])[0]
imgplot = plt.imshow(X_rp1, cmap='binary', origin='lower')
fig1 = plt.gcf()
#plt.show()
plt.draw()
fig1.savefig('D:/Sundar/speech/Speaker/Threshold/0/Sachin/' + file_name +
'_RP' + str(count) + '.png')
def serie_para_imagem(serie,
params_rp=PARAMETROS_RP,
tam_imagem=TAMANHO_IMAGEM_RP,
normalizar=False,
padronizar=False,
tipo_dados=TIPO_DADOS):
"""
Funcao responsavel por gerar e tratar a imagem RP (baseado estudo #17).
"""
# Gerando imagem RP/redimensiona_prndo
imagem = RecurrencePlot(**params_rp).fit_transform([serie])[0]
imagem = cv2.resize(imagem,
dsize=tam_imagem[:2],
interpolation=cv2.INTER_CUBIC).astype(tipo_dados)
if np.sum(imagem) > 0:
# Normalizar
if normalizar:
imagem = (imagem - imagem.min()) / (imagem.max() - imagem.min()
) # MinMax (0,1)
#imagem = (imagem - imagem.mean()) / np.max([imagem.std(), 1e-4])
# # centralizar
# if centralizar:
# imagem -= imagem.mean()
# Padronizar
elif padronizar:
imagem = (imagem - imagem.mean()) / imagem.std(
) #tf.image.per_image_standardization(imagem).numpy()
# N canais
imagem = np.stack([imagem for i in range(tam_imagem[-1])],
axis=-1).astype(tipo_dados)
return imagem
#print(len(frame[:f]))
#print(len(frame[:]))'
# In[103]:
data_rp = []
data_rp.append(frame.values.reshape(1, -1))
data_rp.append(frame.values.reshape(1, -1))
data_rp = np.asarray(data_rp)
# Recurrence plot transformation
#X_rp1 = RecurrencePlot(dimension=3, time_delay=1,threshold=None, percentage=0).fit_transform(data_rp[0])[0]
X_rp1 = RecurrencePlot(dimension=3,
time_delay=1,
threshold='point',
percentage=5).fit_transform(data_rp[0])[0]
imgplot = plt.imshow(X_rp1, cmap='binary', origin='lower')
fig1 = plt.gcf()
plt.show()
plt.draw()
fig1.savefig('Sound/threshold/0/anil/' + 'sample' + '_RP' + '1' + '.png')
# ### Recurrence Plots for A, C & E at None Threshold
# In[ ]:
dir_names = ["/gdrive/My Drive/EEG/S"]
def sig2img(signals):
rp = RecurrencePlot(dimension=1, time_delay=1, threshold=None)
signals.reshape(1,-1)
img = rp.fit_transform(signals)
return img
50 recurrence plots are plotted.
""" # noqa:E501
# Author: Johann Faouzi <*****@*****.**>
# License: BSD-3-Clause
import matplotlib.pyplot as plt
from mpl_toolkits.axes_grid1 import ImageGrid
from pyts.image import RecurrencePlot
from pyts.datasets import load_gunpoint
# Load the GunPoint dataset
X, _, _, _ = load_gunpoint(return_X_y=True)
# Get the recurrence plots for all the time series
rp = RecurrencePlot(threshold='point', percentage=20)
X_rp = rp.fit_transform(X)
# Plot the 50 recurrence plots
fig = plt.figure(figsize=(10, 5))
grid = ImageGrid(fig, 111, nrows_ncols=(5, 10), axes_pad=0.1, share_all=True)
for i, ax in enumerate(grid):
ax.imshow(X_rp[i], cmap='binary', origin='lower')
grid[0].get_yaxis().set_ticks([])
grid[0].get_xaxis().set_ticks([])
fig.suptitle(
"Recurrence plots for the 50 time series in the 'GunPoint' dataset",
y=0.92)
def PSOGSA_ResNet(dataset, max_iters, num_particles, Epochs, NumSave, lr,
resume, savepath):
np.seterr(divide='ignore', invalid='ignore')
# %config InlineBackend.figure_format = 'retina'
c1 = 2
c2 = 2
g0 = 1
dim = 2
w1 = 2
wMax = 0.9
wMin = 0.5
current_fitness = np.zeros((num_particles, 1))
gbest = np.zeros((1, dim))
gbest_score = float('inf')
OldBest = float('inf')
convergence = np.zeros(max_iters)
alpha = 20
epsilon = 1
class Particle:
pass
#all particle initialized
particles = []
Max = 1024
for i in range(num_particles):
p = Particle()
p.params = [
np.random.randint(Max * 0.5, Max),
np.random.uniform(0.2, 0.9)
]
p.fitness = rnd.rand()
p.velocity = 0.3 * rnd.randn(dim)
p.res_force = rnd.rand()
p.acceleration = rnd.randn(dim)
p.force = np.zeros(dim)
p.id = i
particles.append(p)
#training
print('training begain:', dataset)
for i in range(max_iters):
if i % 10 == 0:
print('iteration number:', i)
# gravitational constant
g = g0 * np.exp((-alpha * i) / max_iters)
# calculate mse
cf = 0
for p in particles:
fitness = 0
y_train = 0
if p.params[0] < Max * 0.5 or p.params[0] > Max:
p.params[0] = np.random.randint(Max * 0.5, Max)
if p.params[1] < 0.2 or p.params[1] > 0.9:
p.params[1] = np.random.uniform(0.2, 0.9)
print('hidden size, and contraction coefficients are:',
p.params[0], p.params[1])
[fitness, hidden0] = ResNetBasics.ResNet(dataset, p.params, Epochs,
1, lr, resume, savepath)
hiddensize = int(p.params[0])
# fitness = fitness/X.shape[0]
OldFitness = fitness
current_fitness[cf] = fitness
cf += 1
if gbest_score > fitness and OldBest > fitness:
hiddenState = hidden0.cpu().detach().numpy()
rp = RecurrencePlot()
X_rp = rp.fit_transform(hiddenState)
plt.figure(figsize=(6, 6))
plt.imshow(X_rp[0], cmap='binary', origin='lower')
# plt.title('Recurrence Plot', fontsize=14)
plt.savefig(savepath + 'RecurrencePlots/' +
'RecurrencePlots_' + dataset +
str(round(fitness, NumSave)) + '_' +
str(hiddensize) + '_' + '.png',
dpi=600)
plt.show()
"""weightsName='reservoir.weight_hh'
for name, param in named_parameters:
# print(name,param)
if name.startswith(weightsName):
# set_trace()
torch.save(param,savepath+'weights'+str(round(fitness,6))+'.pt')"""
OldBest = gbest_score
gbest_score = fitness
gbest = p.params
best_fit = min(current_fitness)
worst_fit = max(current_fitness)
for p in particles:
p.mass = (current_fitness[particles.index(p)] -
0.99 * worst_fit) / (best_fit - worst_fit)
for p in particles:
p.mass = p.mass * 5 / sum([p.mass for p in particles])
# gravitational force
for p in particles:
for x in particles[particles.index(p) + 1:]:
p.force = (g * (x.mass * p.mass) *
(np.array(p.params) - np.array(x.params)).tolist()
) / (euclid_dist(p.params, x.params))
# resultant force
for p in particles:
p.res_force = p.res_force + rnd.rand() * p.force
# acceleration
for p in particles:
p.acc = p.res_force / p.mass
w1 = wMin - (i * (wMax - wMin) / max_iters)
# velocity
for p in particles:
p.velocity = w1 * p.velocity + rnd.rand() * p.acceleration + (
rnd.rand() * np.array(gbest) - np.array(p.params)).tolist()
# position
for p in particles:
p.params = p.params + p.velocity
convergence[i] = gbest_score
plt.figure(figsize=(6, 6))
plt.plot(convergence)
plt.xlabel('Convergence')
plt.ylabel('Error')
plt.draw()
plt.savefig(savepath + dataset + '_ConvergenceChanges.png', dpi=600)
sys.stdout.write('\rMPSOGSA is training ResnNet (Iteration = ' +
str(i + 1) + ', MSE = ' + str(gbest_score) + ')')
sys.stdout.flush()
# save results
FileName = dataset + '_BestParameters.csv'
newdata = [max_iters, num_particles, p.params, convergence]
PathFileName = os.path.join(savepath, FileName)
SV.SaveDataCsv(PathFileName, newdata)
os.chdir(processed_data_dir)
plot_params()
# Parameters
n_samples, n_features = 100, 144
# dataset
X = np.load('filtered_calls/LblBla4548_130418-DC-46.npy')
X = X[2900:4000].reshape(1, -1) #3200:3700
# Recurrence plot transformation
#X = np.load('filtered_calls/RedRas3600_110615-DC-10.npy')
#X = X[1500:3000].reshape(1, -1) #3200:3700
rp = RecurrencePlot(dimension=1,
time_delay=1,
threshold='distance',
percentage=5)
n = 250
X_rp = rp.fit_transform(X)
X_new = X_rp[0]
Y = np.zeros((len(X_new) - n * 2, n))
for i in range(len(X_new) - n * 2):
for j in range(n):
Y[i, j] = X_new[i + n, i + n + j]
fig = plt.figure(figsize=(5, 2.5))
ax = fig.add_subplot(1, 1, 1)
ax.imshow(Y.T,
cmap='binary',
origin='lower',
extent=[0, len(X_new) - n * 2, 0, n])
color = sns.color_palette("Set1", n_colors=3, desat=0.7)[0]
parser.add_argument('--maxiter', default=1400, type=int)
parser.add_argument('--gamma',
default=0.1,
type=float,
help='coefficient of clustering loss')
parser.add_argument('--update_interval', default=140, type=int)
parser.add_argument('--tol', default=0.001, type=float)
parser.add_argument('--cae_weights',
default=None,
help='This argument must be given')
args = parser.parse_args()
# load dataset
if args.dataset == 'simulated':
x_vec = pd.read_pickle("data/simulated-data/simulated_timeseries.p")
x = RecurrencePlot(percentage=20).fit_transform(x_vec)
x = x.reshape(x.shape + (1, ))
y = pd.read_pickle("data/simulated-data/simulated_target.p")
n_clusters = len(np.unique(y))
elif args.dataset == 'biological':
x_vec = pd.read_pickle(
"data/biological-data/preprocessed/real_data_timeseries_new.p")
x = pd.read_pickle(
"data/biological-data/preprocessed/real_image_data_new.p")
x = x.reshape(x.shape + (1, ))
x = x / 255.0
y = None
n_clusters = 5
#x = RecurrencePlot(percentage=20).fit_transform(x_vec)
#################################################################################
# You can transform biological timeseries dataset to the image with below code
# Author: Johann Faouzi <*****@*****.**>
# License: BSD-3-Clause
import numpy as np
import matplotlib.pyplot as plt
from pyts.image import RecurrencePlot
# Create a toy time series using the sine function
time_points = np.linspace(0, 4 * np.pi, 1000)
x = np.sin(time_points)
X = np.array([x])
# Recurrence plot transformation
rp = RecurrencePlot(threshold=np.pi/18)
X_rp = rp.transform(X)
# Plot the time series and its recurrence plot
fig = plt.figure(figsize=(6, 6))
gs = fig.add_gridspec(2, 2, width_ratios=(2, 7), height_ratios=(2, 7),
left=0.1, right=0.9, bottom=0.1, top=0.9,
wspace=0.05, hspace=0.05)
# Define the ticks and their labels for both axes
time_ticks = np.linspace(0, 4 * np.pi, 9)
time_ticklabels = [r'$0$', r'$\frac{\pi}{2}$', r'$\pi$',
r'$\frac{3\pi}{2}$', r'$2\pi$', r'$\frac{5\pi}{2}$',
r'$3\pi$', r'$\frac{7\pi}{2}$', r'$4\pi$']
value_ticks = [-1, 0, 1]
import re
from scipy.sparse import csr_matrix
from pyts.classification import SAXVSM
from pyts.image import RecurrencePlot
from pyts.multivariate.transformation import MultivariateTransformer
from pyts.transformation import BOSS
n_samples, n_features, n_timestamps = 40, 3, 30
rng = np.random.RandomState(42)
X = rng.randn(n_samples, n_features, n_timestamps)
@pytest.mark.parametrize(
'params, error, err_msg',
[({
'estimator': [BOSS(), RecurrencePlot(),
SAXVSM()]
}, ValueError, "Estimator 2 must be a transformer."),
({
'estimator': [BOSS()]
}, ValueError, "If 'estimator' is a list, its length must be equal to "
"the number of features (1 != 3)"),
({
'estimator': None
}, TypeError, "'estimator' must be a transformer that inherits from "
"sklearn.base.BaseEstimator or a list thereof.")])
def test_parameter_check(params, error, err_msg):
"""Test parameter validation."""
transformer = MultivariateTransformer(**params)
with pytest.raises(error, match=re.escape(err_msg)):
transformer.fit_transform(X)