Experiment to compare graph and timeseries embeddings.

Author: zangrcar

.gitignore

@@ -170,3 +170,19 @@ RELEASE.md
 *.xml
 fundimentials
 fundamential
+
+tutorials/abnormal_heartbeat/**
+!tutorials/abnormal_heartbeat/.gitkeep
+tutorials/ACSF1/**
+!tutorials/ACSF1/.gitkeep
+tutorials/adiac/**
+!tutorials/adiac/.gitkeep
+tutorials/dodger_loop_weekend/**
+!tutorials/dodger_loop_weekend/.gitkeep
+tutorials/embedding_models/**
+!tutorials/embedding_models/.gitkeep
+tutorials/kendall_tau_results/**
+!tutorials/kendall_tau_results/.gitkeep
+embeddings/ts2vec/**
+!embeddings/ts2vec/.gitkeep
+

README.md

@@ -3,12 +3,12 @@
 TS2G<sup>2</sup> stands for "timeseries to graphs and back". The library implements a variety of strategies to convert timeseries into graphs, and convert graphs into sequences. Below, we provide a code snippet to generate a graph from timeseries:
 
     # load time series from a file
-    timegraph = Timeseries(CsvFile(amazon_path, "Close").from_csv())\
+    timegraph = Timeseries(CsvStock(some_file_path, "ColumnOfInterest").from_csv())\
 
     # and preprocess the timeseries with multiple preprocessing strategies
     .with_preprocessing(TimeseriesPreprocessingComposite()\
-        .add(TimeseriesPreprocessingSegmentation(60, 120))\
-        .add(TimeseriesPreprocessingSlidingWindow(5)))\
+        .add_strategy(TimeseriesPreprocessingSegmentation(60, 120))\
+        .add_strategy(TimeseriesPreprocessingSlidingWindow(5)))\
 
     # then create a graph from the timeseries, following a particular strategy
     .to_graph(BuildTimeseriesToGraphNaturalVisibilityStrategy().get_strategy())\
@@ -17,10 +17,10 @@ TS2G<sup>2</sup> stands for "timeseries to graphs and back". The library impleme
     .link(LinkGraphs().sliding_window())\
 
     # and combine identical graphs that result from the abovementioned time windows into single nodes
-    .combine_identical_subgraphs()\
+    .combine_identical_nodes_slid_win()\
 
     # finally, draw the graph
-    .draw("blue")
+    .draw("red")
 
 For a more detailed example, look at the [Amazon stocks demo](https://github.com/graph-massivizer/ts2g2/blob/main/tutorials/demo-ts2g2.ipynb).
 

core/model.py

@@ -6,14 +6,19 @@
 import matplotlib.pyplot as plt
 import networkx as nx
 import hashlib
+import numpy as np
 
 import to_graph.strategy_linking_multi_graphs as mgl
 import to_graph.strategy_to_graph
 from to_graph.strategy_to_graph import BuildStrategyForTimeseriesToGraph
 import copy
+import math
+from scipy.fft import fft
 
 
-
+class StrategyNotImplementedError(Exception):
+    """Custom exception for strategies that are not implemented."""
+    pass
 
 class Timeseries:
     """Saves extracted data as timeseries."""
@@ -132,6 +137,11 @@ def __init__(self, ts, attribute = 'value'):
         self.attribute = attribute
         self.graph = None
         self.graph_order = []
+        self.histogram_frequencies = None
+        self.histogram_bins = None
+        self.w = 1
+        self.tau = 1
+        self.is_implemented = True
 
     def get_ts(self):
         return self.ts
@@ -142,7 +152,9 @@ def add(self, ts):
             self.ts.append(time_ser)
         return self
 
-    def to_graph(self, strategy: to_graph.strategy_to_graph.BuildStrategyForTimeseriesToGraph):
+
+    def to_graph(self, strategy: to_graph.strategy_to_graph):
+        self.w, self.tau = strategy._get_w_tau()
         for ts in self.ts:
             graph_dict = {}
             order=[]
@@ -151,17 +163,18 @@ def to_graph(self, strategy: to_graph.strategy_to_graph.BuildStrategyForTimeseri
             for timeseries in ts:
                 g =  strategy.to_graph(TimeseriesArrayStream(timeseries))
                 g = g.graph
-
-                for i in range(len(g.nodes)):
-                    old_value = g.nodes[i][self.attribute]
-                    new_value = [old_value]
-                    g.nodes[i][self.attribute] = new_value
+                
+                if strategy._has_value():
+                    for i in range(len(g.nodes)):
+                        old_value = g.nodes[i][self.attribute]
+                        new_value = [old_value]
+                        g.nodes[i][self.attribute] = new_value
 
                 hash = self._hash(g)
                 mapping = {node: f"{hash}_{node}" for node in g.nodes}
                 g = nx.relabel_nodes(g, mapping)
 
-                nx.set_edge_attributes(g, strategy.get_name(), "strategy")
+                nx.set_edge_attributes(g, strategy._get_name(), "strategy")
                 graph_dict[self._hash(g) + f"_{counter}"] = g
                 order.append(self._hash(g) + f"_{counter}")
 
@@ -172,15 +185,15 @@ def to_graph(self, strategy: to_graph.strategy_to_graph.BuildStrategyForTimeseri
 
             self.graphs.append(graph_dict)
             self.graph_order.append(order)
-
-
-        if len(self.ts) == 1 and len(self.ts[0]) == 1:
-            return TimeGraph(self.graph, graphs = self.graphs[0])
+        
+        if (len(self.ts) == 1 and len(self.ts[0]) == 1):
+            return TimeGraph(self.graph, graphs = self.graphs[0], is_implemented=strategy._has_implemented_to_ts(), histogram_frequencies = self.histogram_frequencies, histogram_bins = self.histogram_bins, w = self.w, tau = self.tau)
         else:
+            self.is_implemented = strategy._has_implemented_to_ts()
             return self
 
     def link(self, link_strategy: mgl.LinkGraphs):
-        return TimeGraph(link_strategy.link(self.graphs, self.graph_order), graphs = self.graphs)
+        return TimeGraph(link_strategy.link(self.graphs, self.graph_order), graphs = self.graphs, is_implemented=self.is_implemented, histogram_frequencies = self.histogram_frequencies, histogram_bins = self.histogram_bins, w = self.w, tau = self.tau)
 
     def _get_graphs(self):
         return self.graphs
@@ -195,10 +208,18 @@ def _hash(self, graph):
         """Returns unique hash of this graph."""
         str_to_hash = str(graph.nodes()) + str(graph.edges())
         return hashlib.md5(str_to_hash.encode()).hexdigest()
+    
+    def to_histogram(self, bins):
+        self.histogram_frequencies = []
+        self.histogram_bins = []
+        for i in range(len(self.ts)):
+            a, b = np.histogram(self.ts[i], bins = bins)
+            self.histogram_frequencies.append(a)
+            self.histogram_bins.append(b)
+
+        return self
 
 
-# TODO: to be renamed into TimeGraph?
-# TODO: we need to delete the TimeGraph object (not this one - the redundant one)?
 class TimeGraph:
     """
     Stores already made graph, allows us to add edges and links between nodes.
@@ -208,13 +229,22 @@ class TimeGraph:
     - `graph`: object networkx.Graph
     
     """
-    def __init__(self, graph, graphs = None):
+    def __init__(self, graph, graphs = None, is_implemented = True, histogram_frequencies = None, histogram_bins = None, w = 1, tau = 1):
         self.graph = graph
         self.orig_graph = None
         self.graphs = graphs
         self.attribute = 'value'
         self.sequences = None
         self.sequence_visitor = None
+        self.is_implemented = is_implemented
+        self.histogram_frequencies = histogram_frequencies
+        self.histogram_bins = histogram_bins
+        self.w = w
+        self.tau = tau
+        self.embeddings = None
+
+    def get_is_implemented(self):
+        return self.is_implemented
 
     def _get_graph(self):
         return self.graph
@@ -249,14 +279,16 @@ def combine_identical_subgraphs(self):
                 if node_1 not in self.graph:
                     continue
 
-                for node_2 in list(self.graphs[j].values())[i+1:]:
+                for key, node_2 in list(self.graphs[j].items())[i+1:]:
                     if node_2 == None:
                         break
                     if node_2 not in self.graph:
                         continue
 
                     if(set(list(node_1.edges)) == set(list(node_2.edges))):
                         self.graph = self._combine_subgraphs(self.graph, node_1, node_2, self.attribute)
+                        del self.graphs[j][key]
+                        
 
         return self
 
@@ -303,19 +335,25 @@ def _combine_nodes(self, graph, node_1, node_2, att):
 
     def draw(self, color = "black"):
         """Draws the created graph"""
+        colors = []
+        for j in range(len(self.graph.nodes)):
+            colors.append(color)
         pos=nx.spring_layout(self.graph, seed=1)
-        nx.draw(self.graph, pos, node_size=40, node_color=color)
+        nx.draw(self.graph, pos, node_size=40, node_color=colors)
         plt.show()
         return self
 
     def to_sequence(self, sequence_visitor):
+        if not self.is_implemented:
+            raise StrategyNotImplementedError(f"This function is not yet implemented for this type of graph.")
         self.sequence_visitor = sequence_visitor
         self.sequences = sequence_visitor.to_sequence(self)
         return self
 
     def draw_sequence(self):
         """Draws timeseries."""
-
+        if not self.is_implemented:
+            raise StrategyNotImplementedError(f"This function is not yet implemented for this type of graph.")
         colors = []
         for j in range(len(self.sequences)):
             colors.append("black")
@@ -334,7 +372,28 @@ def plot_timeseries(self, sequence, title, x_legend, y_legend, color):
         plt.xlabel(x_legend)
         plt.ylabel(y_legend)
         plt.grid(True)
+    
+    def _get_histogram(self):
+        return self.histogram_frequencies, self.histogram_bins
+    
+    def _get_w_tau(self):
+        return self.w, self.tau
 
+    def to_embedding(self, embedding_visitor):
+        self.embeddings = embedding_visitor.get_graph_embedding()
+        return self
+    
+    def get_embedding(self):
+        return self.embeddings
+
+
+class VisitorGraphEmbedding:
+    def __init__(self):
+        self.embedding = None
+    
+    def get_graph_embedding(self, graph):
+        self.embedding = np.array(list(nx.eigenvector_centrality_numpy(graph)))
+        return self.embedding
 
 class ToSequenceVisitorMaster:
     """
@@ -451,9 +510,10 @@ def to_sequence(self, graph):
         ts_len = 0
         while len(self.sequences[0]) < self.timeseries_len:
             for j in range(len(self.sequences)):
-
+                
                 index = 0
-                for i in range(len(self.nodes[j])):
+                for i in range(len(list(self.nodes[j]))):
+                
                     if(self._is_equal(current_nodes[j], list(self.graph.nodes)[i])):
                         index = i
                         break
@@ -465,7 +525,7 @@ def to_sequence(self, graph):
             for j in range(self.skip_values + 1):
                 for k in range(len(current_nodes)):
 
-                    current_nodes[k] = self.node_strategy.next_node(ts_len, k, current_nodes, self.switch_graphs, current_nodes[0])
+                    current_nodes[k] = self.node_strategy.next_node(ts_len, k, current_nodes, self.switch_graphs, current_nodes[k])
 
                     if(current_nodes[k] == None):
                         return self
@@ -523,19 +583,19 @@ def to_sequence(self, graph):
 
                 index = 0
 
-                for i in range(len(list(self.nodes[j]))):
-                    if(current_nodes_data[j] == self.data_nodes[j][i]):
-                        index = i
+                for b in range(len(list(self.nodes[j]))):
+                    if(current_nodes_data[j] == self.data_nodes[j][b]):
+                        index = b
                         break
 
                 self.sequences[j] = self.value_strategy.append(self.sequences[j], current_nodes_data[j], j, index)
                 if self.sequences[j][-1] == None:
                     return
-
+                
             for j in range(self.skip_values+1):
                 for k in range(len(current_nodes)):
-                    current_nodes[k] = self.node_strategy.next_node(i, k, current_nodes, self.switch_graphs, current_nodes[0])
-
+                    current_nodes[k] = self.node_strategy.next_node(i, k, current_nodes, self.switch_graphs, current_nodes[k])
+                    
                     new_index = self.nodes[k].index(current_nodes[k])
                     current_nodes_data[k] = self.data_nodes[k][new_index]
                     if(current_nodes[k] == None):
@@ -546,3 +606,72 @@ def to_sequence(self, graph):
 
 
 
+class ToSequenceVisitorOrdinalPartition(ToSequenceVisitorMaster):
+    """Converts graphs made using ordinal partition mechanism back to timeseries"""
+    def __init__(self):
+        super().__init__()
+        self.histogram_frequencies = None
+        self.histogram_bins = None
+        self.w = 1
+        self.tau = 1
+
+    def _set_nodes(self, dict: dict):
+
+        if isinstance(dict, list):
+            graphs = {}
+            for i in range(len(dict)):
+                graphs[list(dict[i].items())[0]] = list(dict[i].values())[0]
+            dict = graphs
+
+        self.nodes = []
+        self.data_nodes = []
+        for graph in dict.values():
+            self.nodes.append(list(graph.nodes))
+            self.data_nodes.append(list(graph.nodes(data=True)))
+        return self
+    
+    def to_sequence(self, graph):
+
+
+        self.graph = graph._get_graph()
+
+        self.histogram_frequencies, self.histogram_bins = graph._get_histogram()
+        self._set_nodes(graph._get_graphs())
+        self.w, self.tau = graph._get_w_tau()
+        one_ts_length = self.timeseries_len/self.tau
+        short_series = [[[] for i in range(self.tau)] for i in range(len(graph._get_graphs()))]
+        current_nodes = [None for _ in range(len(self.nodes))]
+        current_nodes_data = [None for _ in range(len(self.data_nodes))]
+        for i in range(len(self.nodes)):
+            current_nodes[i] = self.nodes[i][0]
+            current_nodes_data[i] = self.data_nodes[i][self.nodes[i].index(current_nodes[i])]
+
+        self.node_strategy.set_arguments(self.graph, self.nodes, {}, self.att)
+
+        i = 0
+        while(len(short_series[0][0]) < one_ts_length):
+            for k in range(len(graph._get_graphs())):
+                for i in range(self.tau):
+                    if(len(short_series[k][i]) == 0):
+                        short_series[k][i] = self.value_strategy.append_start(short_series[k][i], k, current_nodes_data[k], self.histogram_frequencies, self.histogram_bins, self.w)
+                    else:
+                        short_series[k][i] = self.value_strategy.append(short_series[k][i], k, current_nodes_data[k], self.histogram_frequencies, self.histogram_bins, self.w)
+                    if(i < self.tau-1):
+                        current_nodes[k] = self.node_strategy.next_node(i, k, current_nodes, self.switch_graphs, current_nodes[k])
+                        current_nodes_data[k] = self.data_nodes[k][self.nodes[k].index(current_nodes[k])]
+            
+            for j in range(self.skip_values+1):
+                for k in range(len(graph._get_graphs())):
+                    current_nodes[k] = self.node_strategy.next_node(i, k, current_nodes, self.switch_graphs, current_nodes[k])
+                    current_nodes_data[k] = self.data_nodes[k][self.nodes[k].index(current_nodes[k])]
+            
+            i+=1
+        
+        
+        self.sequences = [[] for i in range(len(graph._get_graphs()))]
+        for k in range(len(graph._get_graphs())):
+            for j in range(self.tau):
+                for i in range(len(short_series[k][j])):
+                    self.sequences[k].append(short_series[k][j][i])
+        
+        return self.sequences