def predict(self, X_test): self.check_fitted() if X_test.ndim != 2: raise Exception("X_test should have 2 dimensions! X_dim:{}".format( X_test.ndim)) X_test = np.float32(GPRNP.check_array(X_test)) test_size = X_test.shape[0] arr_offset = 0 length_scale = self.length_scale yhats = np.zeros([test_size, 1]) sigmas = np.zeros([test_size, 1]) eips = np.zeros([test_size, 1]) while arr_offset < test_size: if arr_offset + self.batch_size_ > test_size: end_offset = test_size else: end_offset = arr_offset + self.batch_size_ xt_ = X_test[arr_offset:end_offset] K2 = self.magnitude * np.exp(-ed(self.X_train, xt_) / length_scale) K3 = self.magnitude * np.exp(-ed(xt_, xt_) / length_scale) K2_trans = np.transpose(K2) yhat = np.matmul(K2_trans, np.matmul(self.K_inv, self.y_train)) sigma = np.sqrt(np.diag(K3 - np.matmul(K2_trans, np.matmul(self.K_inv, K2)))) \ .reshape(xt_.shape[0], 1) u = (self.y_best - yhat) / sigma phi1 = 0.5 * special.erf(u / np.sqrt(2.0)) + 0.5 phi2 = (1.0 / np.sqrt(2.0 * np.pi)) * np.exp(np.square(u) * (-0.5)) eip = sigma * (u * phi1 + phi2) yhats[arr_offset:end_offset] = yhat sigmas[arr_offset:end_offset] = sigma eips[arr_offset:end_offset] = eip arr_offset = end_offset GPRNP.check_output(yhats) GPRNP.check_output(sigmas) return GPRResult(yhats, sigmas)
def predict(self, X_test): self.check_fitted() if X_test.ndim != 2: raise Exception("X_test should have 2 dimensions! X_dim:{}" .format(X_test.ndim)) X_test = np.float32(GPRNP.check_array(X_test)) test_size = X_test.shape[0] arr_offset = 0 length_scale = self.length_scale yhats = np.zeros([test_size, 1]) sigmas = np.zeros([test_size, 1]) eips = np.zeros([test_size, 1]) while arr_offset < test_size: if arr_offset + self.batch_size_ > test_size: end_offset = test_size else: end_offset = arr_offset + self.batch_size_ xt_ = X_test[arr_offset:end_offset] K2 = self.magnitude * np.exp(-ed(self.X_train, xt_) / length_scale) K3 = self.magnitude * np.exp(-ed(xt_, xt_) / length_scale) K2_trans = np.transpose(K2) yhat = np.matmul(K2_trans, np.matmul(self.K_inv, self.y_train)) sigma = np.sqrt(np.diag(K3 - np.matmul(K2_trans, np.matmul(self.K_inv, K2)))) \ .reshape(xt_.shape[0], 1) u = (self.y_best - yhat) / sigma phi1 = 0.5 * special.erf(u / np.sqrt(2.0)) + 0.5 phi2 = (1.0 / np.sqrt(2.0 * np.pi)) * np.exp(np.square(u) * (-0.5)) eip = sigma * (u * phi1 + phi2) yhats[arr_offset:end_offset] = yhat sigmas[arr_offset:end_offset] = sigma eips[arr_offset:end_offset] = eip arr_offset = end_offset GPRNP.check_output(yhats) GPRNP.check_output(sigmas) return GPRResult(yhats, sigmas)
def sens_range(self, i, kh_pos): r"""Get the sensing distance for ith krill individual. :param i: Index of ith krill individual :param kh_pos: The position of krill herd :return: The sensing distance for ith krill individual """ return sum([ed(kh_pos[i], kh_pos[j]) for j in range(self.population)]) / (self.nn * self.population)
def funX(self, x, y): r"""Get x values. Args: x (numpy.ndarray): First krill/individual. y (numpy.ndarray): Second krill/individual. Returns: numpy.ndarray: -- """ return ((y - x) + self.epsilon) / (ed(y, x) + self.epsilon)
def sensRange(self, ki, KH): r"""Calculate sense range for selected individual. Args: ki (int): Selected individual. KH (numpy.ndarray): Krill heard population. Returns: float: Sense range for krill. """ return sum([ed(KH[ki], KH[i]) for i in range(self.NP)]) / (self.nn * self.NP)
def get_neighbors(self, i, ids, kh_pos): r"""Get neighbors of ith krill individual. :param i: Index of ith krill individual :param ids: Sensing distance of ith krill individual :param kh_pos: The position of krill herd :return: {list} - Neighbors of ith krill individual. """ neighbors = list() n = 0 for j in range(self.population): if n < self.nn and j != i and ed(kh_pos[i], kh_pos[j]) < ids: n += 1 neighbors.append(j) return neighbors
def getNeighbours(self, i, ids, KH): r"""Get neighbours. Args: i (int): Individual looking for neighbours. ids (float): Maximal distance for being a neighbour. KH (numpy.ndarray): Current population. Returns: numpy.ndarray: Neighbours of krill heard. """ N = list() for j in range(self.NP): if j != i and ids > ed(KH[i], KH[j]): N.append(j) if not N: N.append(self.randint(self.NP)) return asarray(N)
def fit(self, X_train, y_train, ridge=0.01): self._reset() X_train, y_train = self.check_X_y(X_train, y_train) if X_train.ndim != 2 or y_train.ndim != 2: raise Exception("X_train or y_train should have 2 dimensions! X_dim:{}, y_dim:{}" .format(X_train.ndim, y_train.ndim)) self.X_train = np.float32(X_train) self.y_train = np.float32(y_train) sample_size = self.X_train.shape[0] if np.isscalar(ridge): ridge = np.ones(sample_size) * ridge assert isinstance(ridge, np.ndarray) assert ridge.ndim == 1 K = self.magnitude * np.exp(-ed(self.X_train, self.X_train) / self.length_scale) \ + np.diag(ridge) K_inv = np.linalg.inv(K) self.K = K self.K_inv = K_inv self.y_best = np.min(y_train) return self
def fit(self, X_train, y_train, ridge=0.01): self._reset() X_train, y_train = self.check_X_y(X_train, y_train) if X_train.ndim != 2 or y_train.ndim != 2: raise Exception( "X_train or y_train should have 2 dimensions! X_dim:{}, y_dim:{}" .format(X_train.ndim, y_train.ndim)) self.X_train = np.float32(X_train) self.y_train = np.float32(y_train) sample_size = self.X_train.shape[0] if np.isscalar(ridge): ridge = np.ones(sample_size) * ridge assert isinstance(ridge, np.ndarray) assert ridge.ndim == 1 K = self.magnitude * np.exp(-ed(self.X_train, self.X_train) / self.length_scale) \ + np.diag(ridge) K_inv = np.linalg.inv(K) self.K = K self.K_inv = K_inv self.y_best = np.min(y_train) return self
def sensRange(self, ki, KH): return sum([ed(KH[ki], KH[i]) for i in range(self.N)]) / (self.nn * self.N)
def funX(self, x, y): return ((y - x) + self.epsilon) / (ed(y, x) + self.epsilon)
def getNeigbors(self, i, ids, KH): N = list() for j in range(self.N): if j != i and ids > ed(KH[i], KH[j]): N.append(j) return N
def color_calculation(self, one_pos): dis_min = inf for ref_point in self.ref_points: dis = ed(ref_point, one_pos) dis_min = dis if dis < dis_min else dis_min return 'g' if dis_min < self.threshold else 'g'
def funX(self, x, y): return ((y - x) + self.epsilon) / (ed(y, x) + self.epsilon) def funK(self, x, y, b, w): return ((x - y) + self.epsilon) / ((w - b) + self.epsilon)
def SFc_means(attr_vector, k, seeds, seeds_classes, centroids, threshold, z, total_grouping=0): """ A function, k-means like, that generate k groups in the data entry based on pre-estabilished centroids and a precision threshold. Args: attr_vector: atribute vector of each element (ndarray [MxN]; M is the number of attributes and N the number of elements); k: quantity of groups (int); seeds: rodulated elements used as first centroids (ndarray [MxZ], M is the number of attributes and Z the number of seeds); seeds_classes: array with atributes vector classes; (ndarray [N]; N is the number of elements) centroids: position of seeds (ndarray; [Z], Z is the number of seeds, each element represents a position at attr_vector); threshold: percetage used to calculate the rotulation precision; z: nebulosity level; total_grouping: used to set the grouping type (int; 0 to parcial grouping (based on threshold) and 1 to total grouping); Returns: An [N] array of labels, that N is the number of entries. """ def verify_equality(vector, threshold): """ Verify if the first threshold number of vector elemets have the same value. Args: vector: a list with numbers (list); threshold: the number of vector elements to verify (int). Returns: True if the first threshold number of vector elements have the same value and False if they have not. """ actual_value = vector[0] for i in range(1, threshold): if vector[i] != actual_value: return False actual_value = vector[i] return True # generating unique array to avoid repeated data and the positions of the original array elements in the new unique elements array histogram, positions_histogram = np.unique(attr_vector, axis=0, return_inverse=True) # creating an zeros array to storage the future classes (one for each element from attr_vector) labels = np.zeros((len(histogram))) hist_centroids = np.zeros(np.unique(seeds, axis=0).shape[0]) hist_seeds = np.zeros(np.unique(seeds, axis=0).shape) hist_seeds_classes = np.zeros(np.unique(seeds, axis=0).shape[0]) counter = 0 for i in range(len(centroids)): histogram_position = positions_histogram[centroids[i]] labels[histogram_position] = seeds_classes[i] if len(np.nonzero(hist_centroids == positions_histogram)[0]) == 0: hist_centroids[counter] = histogram_position hist_seeds[counter, :] = seeds[i, :] hist_seeds_classes[counter] = seeds_classes[i] counter += 1 expoent = 1 / (z - 1) #for each element from attr_vector for i in range(len(labels)): if len(np.nonzero( hist_centroids == i)[0]) == 0: #but only the not labeled ones pertinency_levels = [] distances = [] #calculate the euclidean distances between the element and all the centroids for j in range(len(hist_centroids)): distances.append(ed(histogram[i], hist_seeds[j])) #calculate the pertinency level of the element to every centroid for j in range(len(hist_centroids)): mu = 0 for k in range(len(hist_centroids)): mu += (distances[j] / distances[k])**expoent mu = mu**-1 pertinency_levels.append([mu, hist_seeds_classes[j]]) #sorting pertinency_levels list in descending order pertinency_levels.sort(key=lambda x: x[0], reverse=True) pertinency_levels = np.asarray(pertinency_levels) if total_grouping == 0: #calculating absolute threshold based on percetage threshold and the provided centroids number absolute_threshold = mt.floor(len(centroids) * threshold) #verify if the first (absolute_threshold) items are from the same group #[item[0] for item in pertinency_levels] if verify_equality(pertinency_levels[:, 1], absolute_threshold): #if yes, the unlabeled data label are the same from the highest pertinency level labels[i] = pertinency_levels[0][1] else: labels[i] = pertinency_levels[0][1] final_labels = np.zeros(len(attr_vector)) for i in range(len(final_labels)): final_labels[i] = labels[positions_histogram[i]] return final_labels