Matlab: Может ли SOM и kmeans применяться к данным временного ряда бинаризации?

Question

Я нашел аналогичный вопрос, заданный здесь Determining cluster membership in SOM (Self Organizing Map) for time series data

и я хочу узнать, как применять самоорганизующуюся карту при бинаризации или присваивать данные более чем двум типам символов.

Например, data = rand(100,1) В общем, я бы делал data_quantized = 2*(data>=0.5)-1, чтобы получить двоичную преобразованную серию, где предполагается и фиксируется порог 0,5. Возможно, было возможно квантовать данные, используя более двух символов. Можно ли применять к ним или к ЗВОЛ для выполнения этой задачи? Каким должен быть ввод и вывод, если я буду использовать SOM для квантования данных?

X = {x_i(t)} для i = 1: N и t = 1: T число временных рядов, N представляет количество компонентов/переменных. Чтобы получить квантованное значение для любого вектора x_i, нужно использовать значение BMU, которое является ближайшим. Ошибка квантования будет евклидовой нормой разности входного вектора и модели наилучшего соответствия. Затем новый временной ряд сравнивается/сопоставляется с использованием представления символов временного ряда. WOul BMU - скалярное число или вектор чисел с плавающей запятой? Очень сложно понять, что делает ЗВОЛ.

реализация Matlab https://www.mathworks.com/matlabcentral/fileexchange/39930-self-organizing-map-simple-demonstration

Я не могу понять, как работать для временных рядов квантования. Предполагая N = 1, одномерный массив/вектор элементов, полученных из процесса белого шума, как я могу квантовать/разбивать эти данные с помощью самоорганизующейся карты?

http://www.mathworks.com/help/nnet/ug/cluster-with-self-organizing-map-neural-network.html

обеспечивается Matlab, но это работает для N одномерных данных, но у меня есть 1 размерные данные, содержащие 1000 точек данных (т = 1, ..., 1000).

Это будет огромной помощью, если представлен пример игрушки, который объясняет, как временные ряды могут быть квантованы на несколько уровней. Пусть, trainingData = x_i;

T = 1000; 
N = 1; 
x_i = rand(T,N) ; 

Как я могу применить код ниже сома так, что численные значных данные могут быть представлены символами, такие как 1,2,3 т.е. кластеризованную с использованием 3 символов? Точка данных (скалярные значения) может быть либо представлена ​​символом 1 или 2 или 3.

function som = SOMSimple(nfeatures, ndim, nepochs, ntrainingvectors, eta0, etadecay, sgm0, sgmdecay, showMode) 
%SOMSimple Simple demonstration of a Self-Organizing Map that was proposed by Kohonen. 
% sommap = SOMSimple(nfeatures, ndim, nepochs, ntrainingvectors, eta0, neta, sgm0, nsgm, showMode) 
% trains a self-organizing map with the following parameters 
%  nfeatures  - dimension size of the training feature vectors 
%  ndim    - width of a square SOM map 
%  nepochs   - number of epochs used for training 
%  ntrainingvectors - number of training vectors that are randomly generated 
%  eta0    - initial learning rate 
%  etadecay   - exponential decay rate of the learning rate 
%  sgm0    - initial variance of a Gaussian function that 
%       is used to determine the neighbours of the best 
%       matching unit (BMU) 
%  sgmdecay   - exponential decay rate of the Gaussian variance 
%  showMode   - 0: do not show output, 
%       1: show the initially randomly generated SOM map 
%        and the trained SOM map, 
%       2: show the trained SOM map after each update 
% 
% For example: A demonstration of an SOM map that is trained by RGB values 
%   
%  som = SOMSimple(1,60,10,100,0.1,0.05,20,0.05,2); 
%  % It uses: 
%  % 1 : dimensions for training vectors 
%  % 60x60: neurons 
%  % 10 : epochs 
%  % 100 : training vectors 
%  % 0.1 : initial learning rate 
%  % 0.05 : exponential decay rate of the learning rate 
%  % 20 : initial Gaussian variance 
%  % 0.05 : exponential decay rate of the Gaussian variance 
%  % 2 : Display the som map after every update 

nrows = ndim; 
ncols = ndim; 
nfeatures = 1; 
som = rand(nrows,ncols,nfeatures); 


% Generate random training data 
    x_i = trainingData; 

% Generate coordinate system 
[x y] = meshgrid(1:ncols,1:nrows); 

for t = 1:nepochs  
    % Compute the learning rate for the current epoch 
    eta = eta0 * exp(-t*etadecay);   

    % Compute the variance of the Gaussian (Neighbourhood) function for the ucrrent epoch 
    sgm = sgm0 * exp(-t*sgmdecay); 

    % Consider the width of the Gaussian function as 3 sigma 
    width = ceil(sgm*3);   

    for ntraining = 1:ntrainingvectors 
     % Get current training vector 
     trainingVector = trainingData(ntraining,:); 

     % Compute the Euclidean distance between the training vector and 
     % each neuron in the SOM map 
     dist = getEuclideanDistance(trainingVector, som, nrows, ncols, nfeatures); 

     % Find the best matching unit (bmu) 
     [~, bmuindex] = min(dist); 

     % transform the bmu index into 2D 
     [bmurow bmucol] = ind2sub([nrows ncols],bmuindex);   

     % Generate a Gaussian function centered on the location of the bmu 
     g = exp(-(((x - bmucol).^2) + ((y - bmurow).^2))/(2*sgm*sgm)); 

     % Determine the boundary of the local neighbourhood 
     fromrow = max(1,bmurow - width); 
     torow = min(bmurow + width,nrows); 
     fromcol = max(1,bmucol - width); 
     tocol = min(bmucol + width,ncols); 

     % Get the neighbouring neurons and determine the size of the neighbourhood 
     neighbourNeurons = som(fromrow:torow,fromcol:tocol,:); 
     sz = size(neighbourNeurons); 

     % Transform the training vector and the Gaussian function into 
     % multi-dimensional to facilitate the computation of the neuron weights update 
     T = reshape(repmat(trainingVector,sz(1)*sz(2),1),sz(1),sz(2),nfeatures);     
     G = repmat(g(fromrow:torow,fromcol:tocol),[1 1 nfeatures]); 

     % Update the weights of the neurons that are in the neighbourhood of the bmu 
     neighbourNeurons = neighbourNeurons + eta .* G .* (T - neighbourNeurons); 

     % Put the new weights of the BMU neighbouring neurons back to the 
     % entire SOM map 
     som(fromrow:torow,fromcol:tocol,:) = neighbourNeurons; 


    end 
end 


function ed = getEuclideanDistance(trainingVector, sommap, nrows, ncols, nfeatures) 

% Transform the 3D representation of neurons into 2D 
neuronList = reshape(sommap,nrows*ncols,nfeatures);    

% Initialize Euclidean Distance 
ed = 0; 
for n = 1:size(neuronList,2) 
    ed = ed + (trainingVector(n)-neuronList(:,n)).^2; 
end 
ed = sqrt(ed); 

Answer 1

Я не знаю, что я мог бы быть недопонимания вашего вопроса, но от того, что я понимаю, это на самом деле довольно прямо вперед , как с kmeans, так и с собственным Matlab selforgmap. Реализация, которую вы опубликовали для SOMSimple, я не могу прокомментировать.

Давайте ваш первоначальный пример:

rng(1337); 
T = 1000; 
x_i = rand(1,T); %rowvector for convenience 

Предполагая, что вы хотите, чтобы квантовать до трех символов, ваша версия руководства может быть:

nsyms = 3; 
symsthresh = [1:-1/nsyms:1/nsyms]; 
x_i_q = zeros(size(x_i)); 

for i=1:nsyms 
    x_i_q(x_i<=symsthresh(i)) = i; 
end 

Использование Matlab собственного selforgmap вы можете достичь такого же результата:

net = selforgmap(nsyms); 
net.trainParam.showWindow = false; 
net = train(net,x_i); 
net(x_i); 
y = net(x_i); 
classes = vec2ind(y); 

Наконец, то же самое можно сделать прямо rwardly с kmeans:

clusters = kmeans(x_i',nsyms)';