Homec4science
Diffusion MeshDRefinement (master) Browse

R12728/Dataset.py
1e34ae800aa7master

Last Change
Raw File

Dataset.py
View Options

from sklearn.neighbors import KDTree
import numpy as np
import multiprocessing as mp
class Dataset:
def __init__(self, datapoints, Ce, ordering = True, compartiments=20):
self.Ce = Ce
datapoints = self.normalizeDP(datapoints)
self.DP = datapoints
if ordering:
self.tree = KDTree(datapoints, leaf_size=10)
self.isOrdered = True
self.compartiments = compartiments
else:
self.isOrdered = False
def get_points(self, selector):
sqrtCe = np.sqrt(self.Ce)
normalized_points = self.DP[selector]
points = normalized_points*np.array([1./sqrtCe, sqrtCe])
return points
def normalizeDP(self, datapoints):
sqrtCe = np.sqrt(self.Ce)
normalizedDP = datapoints*np.array([sqrtCe, 1./sqrtCe])
return normalizedDP
def find_closest(self, epsi, sigma, weights, parallel=False):
if len(epsi)==0:
return np.zeros(0).astype('int'), 0
sqrtCe = np.sqrt(self.Ce)
epsi = epsi*sqrtCe
sigma = sigma/sqrtCe
if self.isOrdered:
return self._KDsearch(epsi, sigma, weights, parallel)
else:
return self._linearsearch(epsi, sigma, weights)
def _KDsearch(self, epsi, sigma, weights, parallel):
if parallel:
distances, closest_indices = self._parallel_search(np.vstack([epsi, sigma]).T)
else:
distances, closest_indices = self.tree.query(np.vstack([epsi, sigma]).T)
weighted_total_distance = np.sum(np.multiply(distances,weights))
return closest_indices.ravel(), weighted_total_distance
def _parallel_search(self, points):
nproc = mp.cpu_count()-1
pool = mp.Pool(nproc)
#results = pool.map(self.tree.query, [point.reshape(1, -1) for point in points])
results = pool.map(self.tree.query, np.array_split(points, nproc))
indices = []
distances = []
for r in results:
indices.append(r[0])
distances.append(r[1])
return np.vstack(indices).ravel().astype('int'), np.vstack(distances).ravel()
def _linearsearch(self, epsis, sigmas, weights):
N = len(epsis)
closest_indices = np.zeros(N).astype('int')
weighted_total_distance = 0
for i in range(N):
e,s,w = epsis[i], sigmas[i], weights[i]
distances = self._compute_distance(e, s,w)
closest_index = np.argmin(distances)
closest_indices[i]=closest_index
weighted_total_distance += np.min(distances)*w
return closest_indices, weighted_total_distance
def _compute_distance(self, epsi, sigma, weight):
depsi = epsi-self.DP[:,0]
dsigma = sigma-self.DP[:,1]
return self._F_cost(depsi, dsigma, weight)
def _F_cost(self, epsis, sigmas, weights):
We = lambda x : 0.5*x**2
We_s = lambda x : 0.5*x**2
return np.multiply(weights, We(epsis)+We_s(sigmas))
c4science · Help