From 9a79c66af5beb3faf3f6043d16a3f8500e892787 Mon Sep 17 00:00:00 2001 From: linlin Date: Tue, 6 Oct 2020 17:24:15 +0200 Subject: [PATCH] New translations graph_kernel.py (Chinese Simplified) --- lang/zh/gklearn/kernels/graph_kernel.py | 227 ++++++++++++++++++++++++++++++++ 1 file changed, 227 insertions(+) create mode 100644 lang/zh/gklearn/kernels/graph_kernel.py diff --git a/lang/zh/gklearn/kernels/graph_kernel.py b/lang/zh/gklearn/kernels/graph_kernel.py new file mode 100644 index 0000000..7c6afde --- /dev/null +++ b/lang/zh/gklearn/kernels/graph_kernel.py @@ -0,0 +1,227 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +""" +Created on Mon Mar 30 11:52:47 2020 + +@author: ljia +""" +import numpy as np +import networkx as nx +import multiprocessing +import time + + +class GraphKernel(object): + + def __init__(self): + self._graphs = None + self._parallel = '' + self._n_jobs = 0 + self._verbose = None + self._normalize = True + self._run_time = 0 + self._gram_matrix = None + self._gram_matrix_unnorm = None + + + def compute(self, *graphs, **kwargs): + self._parallel = kwargs.get('parallel', 'imap_unordered') + self._n_jobs = kwargs.get('n_jobs', multiprocessing.cpu_count()) + self._normalize = kwargs.get('normalize', True) + self._verbose = kwargs.get('verbose', 2) + + if len(graphs) == 1: + if not isinstance(graphs[0], list): + raise Exception('Cannot detect graphs.') + elif len(graphs[0]) == 0: + raise Exception('The graph list given is empty. No computation was performed.') + else: + self._graphs = [g.copy() for g in graphs[0]] + self._gram_matrix = self.__compute_gram_matrix() + self._gram_matrix_unnorm = np.copy(self._gram_matrix) + if self._normalize: + self._gram_matrix = self.normalize_gm(self._gram_matrix) + return self._gram_matrix, self._run_time + + elif len(graphs) == 2: + if self.is_graph(graphs[0]) and self.is_graph(graphs[1]): + kernel = self.__compute_single_kernel(graphs[0].copy(), graphs[1].copy()) + return kernel, self._run_time + elif self.is_graph(graphs[0]) and isinstance(graphs[1], list): + g1 = graphs[0].copy() + g_list = [g.copy() for g in graphs[1]] + kernel_list = self.__compute_kernel_list(g1, g_list) + return kernel_list, self._run_time + elif isinstance(graphs[0], list) and self.is_graph(graphs[1]): + g1 = graphs[1].copy() + g_list = [g.copy() for g in graphs[0]] + kernel_list = self.__compute_kernel_list(g1, g_list) + return kernel_list, self._run_time + else: + raise Exception('Cannot detect graphs.') + + elif len(graphs) == 0 and self._graphs is None: + raise Exception('Please add graphs before computing.') + + else: + raise Exception('Cannot detect graphs.') + + + def normalize_gm(self, gram_matrix): + import warnings + warnings.warn('gklearn.kernels.graph_kernel.normalize_gm will be deprecated, use gklearn.utils.normalize_gram_matrix instead', DeprecationWarning) + + diag = gram_matrix.diagonal().copy() + for i in range(len(gram_matrix)): + for j in range(i, len(gram_matrix)): + gram_matrix[i][j] /= np.sqrt(diag[i] * diag[j]) + gram_matrix[j][i] = gram_matrix[i][j] + return gram_matrix + + + def compute_distance_matrix(self): + if self._gram_matrix is None: + raise Exception('Please compute the Gram matrix before computing distance matrix.') + dis_mat = np.empty((len(self._gram_matrix), len(self._gram_matrix))) + for i in range(len(self._gram_matrix)): + for j in range(i, len(self._gram_matrix)): + dis = self._gram_matrix[i, i] + self._gram_matrix[j, j] - 2 * self._gram_matrix[i, j] + if dis < 0: + if dis > -1e-10: + dis = 0 + else: + raise ValueError('The distance is negative.') + dis_mat[i, j] = np.sqrt(dis) + dis_mat[j, i] = dis_mat[i, j] + dis_max = np.max(np.max(dis_mat)) + dis_min = np.min(np.min(dis_mat[dis_mat != 0])) + dis_mean = np.mean(np.mean(dis_mat)) + return dis_mat, dis_max, dis_min, dis_mean + + + def __compute_gram_matrix(self): + start_time = time.time() + + if self._parallel == 'imap_unordered': + gram_matrix = self._compute_gm_imap_unordered() + elif self._parallel == None: + gram_matrix = self._compute_gm_series() + else: + raise Exception('Parallel mode is not set correctly.') + + self._run_time = time.time() - start_time + if self._verbose: + print('Gram matrix of size %d built in %s seconds.' + % (len(self._graphs), self._run_time)) + + return gram_matrix + + + def _compute_gm_series(self): + pass + + + def _compute_gm_imap_unordered(self): + pass + + + def __compute_kernel_list(self, g1, g_list): + start_time = time.time() + + if self._parallel == 'imap_unordered': + kernel_list = self._compute_kernel_list_imap_unordered(g1, g_list) + elif self._parallel == None: + kernel_list = self._compute_kernel_list_series(g1, g_list) + else: + raise Exception('Parallel mode is not set correctly.') + + self._run_time = time.time() - start_time + if self._verbose: + print('Graph kernel bewteen a graph and a list of %d graphs built in %s seconds.' + % (len(g_list), self._run_time)) + + return kernel_list + + + def _compute_kernel_list_series(self, g1, g_list): + pass + + + def _compute_kernel_list_imap_unordered(self, g1, g_list): + pass + + + def __compute_single_kernel(self, g1, g2): + start_time = time.time() + + kernel = self._compute_single_kernel_series(g1, g2) + + self._run_time = time.time() - start_time + if self._verbose: + print('Graph kernel bewteen two graphs built in %s seconds.' % (self._run_time)) + + return kernel + + + def _compute_single_kernel_series(self, g1, g2): + pass + + + def is_graph(self, graph): + if isinstance(graph, nx.Graph): + return True + if isinstance(graph, nx.DiGraph): + return True + if isinstance(graph, nx.MultiGraph): + return True + if isinstance(graph, nx.MultiDiGraph): + return True + return False + + + @property + def graphs(self): + return self._graphs + + + @property + def parallel(self): + return self._parallel + + + @property + def n_jobs(self): + return self._n_jobs + + + @property + def verbose(self): + return self._verbose + + + @property + def normalize(self): + return self._normalize + + + @property + def run_time(self): + return self._run_time + + + @property + def gram_matrix(self): + return self._gram_matrix + + @gram_matrix.setter + def gram_matrix(self, value): + self._gram_matrix = value + + + @property + def gram_matrix_unnorm(self): + return self._gram_matrix_unnorm + + @gram_matrix_unnorm.setter + def gram_matrix_unnorm(self, value): + self._gram_matrix_unnorm = value \ No newline at end of file