def fit(self, X, y=None): # Compute the codebook self.codebook = Codebook(K=self.K, no_dump=self.no_dump_codebook, force_reload=self.force_reload) self.codebook.fit(X) return self
def __init__(self, shape): self.codebooks = [] self.height = shape[1] self.width = shape[0] for i in range(self.width): for j in range(self.height): self.codebooks.append(Codebook())
def train(self, instances, dev_set=None, max_epoch=30, learning_rate=.5, batch_size=30): # Construct a statistical model from labeled instances. self.codebook = Codebook() self.codebook.supervised_populate(instances) self.parameters = np.zeros((self.codebook.dimension())) self._train_sgd(instances, dev_set, max_epoch, learning_rate, batch_size)
def __init__(self, data, neighborhood, normalizer=None, mapsize=None, mask=None, mapshape='planar', lattice='rect', initialization='pca', training='batch', name='sompy', component_names=None): """ Self Organizing Map :param data: data to be clustered, represented as a matrix of n rows, as inputs and m cols as input features :param neighborhood: neighborhood object calculator. :param normalizer: normalizer object calculator. :param mapsize: tuple/list defining the dimensions of the som. If single number is provided is considered as the number of nodes. :param mask: mask :param mapshape: shape of the som. :param lattice: type of lattice. :param initialization: method to be used for initialization of the som. :param name: name used to identify the som :param training: Training mode (seq, batch) """ self._data = normalizer.normalize(data) if normalizer else data self._normalizer = normalizer self._dim = data.shape[1] self._dlen = data.shape[0] self._dlabel = None self._bmu = None self.name = name self.data_raw = data self.neighborhood = neighborhood self.mapshape = mapshape self.initialization = initialization self.mask = mask or np.ones([1, self._dim]) mapsize = self.calculate_map_size(lattice) if not mapsize else mapsize self.codebook = Codebook(mapsize, lattice) self.training = training self._component_names = self.build_component_names( ) if component_names is None else [component_names] self._distance_matrix = self.calculate_map_dist()
def __init__(self, Y, D, sigma, b=1e-8, scale=1): self.input_shape = Y.shape self.sigma = sigma self.scale = scale m, r, c = D.shape _, _, self.h, self.w = Y.shape self.hx = int(np.ceil(self.h * scale)) if self.h > 1 else self.h self.wx = int(np.ceil(self.w * scale)) if self.w > 1 else self.w bh = int(2 * np.ceil(3 * sigma[0] * scale) + 1) if self.h > 1 else 1 bw = int(2 * np.ceil(3 * sigma[1] * scale) + 1) if self.w > 1 else 1 self.psf_support_scaled = (bh, bw) bh = int(2 * np.ceil(3 * sigma[0]) + 1) if self.h > 1 else 1 bw = int(2 * np.ceil(3 * sigma[1]) + 1) if self.w > 1 else 1 self.psf_support = (bh, bw) # Set up X x_shape = (m, self.hx, self.wx) self.X = torch.ones(x_shape).float() # Set up Y self.Y = torch.tensor(Y).float().flatten(start_dim=0, end_dim=1) # Set up b self.b = torch.tensor(b).float() if self.b.ndim == 4: self.b = self.b.flatten(start_dim=0, end_dim=1) # Set up codebook self.codebook = Codebook(D) # Set up spatial blurr self.psf = PSF((self.h, self.w), sigma, scale) # Prepare constant ones_channels = torch.ones((r * c, 1, 1)) ones_space = torch.ones((1, self.h, self.w)) self.denominator = self.codebook.matmul_t(ones_channels) * \ self.psf.matmul_t(ones_space) # Compute Yhat = DXG self.Yhat = self.__forward(self.X)
def codebook(self): """ Export a text file code book of categories and codes. """ Codebook(self.app, self.ui.textEdit)
def build_codebook(encoder, dataset, args): embed_bb = args.getboolean('Embedding', 'EMBED_BB') codebook = Codebook(encoder, dataset, embed_bb) return codebook
"../images/Crowd_PETS09/S0/Background/View_001/Time_13-06/")) EPSILON_1 = 1 TRAIN_N_IMG = 10 if __name__ == '__main__': img_list = os.listdir(TRAINING_PATH)[:TRAIN_N_IMG] for it, file in enumerate(img_list): img = cv2.cvtColor(cv2.imread(os.path.join(TRAINING_PATH, file)), cv2.COLOR_BGR2RGB).astype(float) if it == 0: codebooks = np.array( [Codebook() for pixel in range(img.shape[0] * img.shape[1])]) for px_row in img: for px_idx, px in enumerate(px_row): R = px[0] G = px[1] B = px[2] X = np.array([R, G, B]) I = sqrt(R**2 + G**2 + B**2) pixel = Pixel(X, I) codebook_empty = True no_match = True for codeword in codebooks[px_idx].codewords:
def fit(self, X, y=None): # Compute the codebook self.codebook = Codebook(K=self.K, no_dump=self.no_dump_codebook) self.codebook.fit(X['descriptors']) return self
def __init__(self, data, neighborhood, normalizer=None, mapsize=None, mask=None, mapshape='planar', lattice='rect', initialization='pca', training='batch', radius_train='linear', name='sompy', component_names=None, components_to_plot=None, isNormalized=False): """ Self Organizing Map :param data: data to be clustered, represented as a matrix of n rows, as inputs and m cols as input features :param neighborhood: neighborhood object calculator. :param normalizer: normalizer object calculator. :param mapsize: tuple/list defining the dimensions of the som. If single number is provided is considered as the number of nodes. :param mask: mask :param mapshape: shape of the som. :param lattice: type of lattice. :param initialization: method to be used for initialization of the som. :param name: name used to identify the som :param training: Training mode (seq, batch) """ if data is not None: # ajout LB if normalizer and isNormalized == False: for i in range(len(normalizer)): data[:, i] = normalizer[i].normalize(data[:, i]) self._data = data else: self._data = data self._data = self._data.astype('double') # ajout LB self._dim = data.shape[1] self._dlen = data.shape[0] else: self._data = None self._dim = None self._dlen = None self._normalizer = normalizer self._dlabel = None self._bmu = None self.name = name self.data_raw = data self.neighborhood = neighborhood self.mapshape = mapshape self.initialization = initialization self.mask = mask mapsize = self.calculate_map_size(lattice) if not mapsize else mapsize self.mapsize = mapsize self.codebook = Codebook(mapsize, lattice) self.training = training self.radius_train = radius_train self._component_names = self.build_component_names( ) if component_names is None else [component_names] self._distance_matrix = self.calculate_map_dist() self.components_to_plot = components_to_plot
def __init__(self, data, neighborhood, normalizer=None, mapsize=None, mask=None, mapshape='planar', lattice='rect', initialization='pca', training='batch', name='sompy'): """ Self Organizing Map :param data: data to be clustered, represented as a matrix of n rows, as inputs and m cols as input features :param neighborhood: neighborhood object calculator. :param normalizer: normalizer object calculator. :param mapsize: tuple/list defining the dimensions of the som. If single number is provided is considered as the number of nodes. :param mask: mask :param mapshape: shape of the som. :param lattice: type of lattice. :param initialization: method to be used for initialization of the som. :param name: name used to identify the som :param training: Training mode (seq, batch) """ print "DDDD", data self._data = data # normalizer.normalize(data) if normalizer else data print "data : \n", self._data print "map size : ", mapsize self._normalizer = normalizer print "_normalizer is a object to class normalizer : ", self._normalizer self._dim = data.shape[1] print "data shape[1] : ", self._dim self._dlen = data.shape[0] print "data shape[0] : ", data.shape[0] self._dlabel = None print "data label : ", self._dlabel self._bmu = None print "intial bmu : ", self._bmu self.name = name print "name : ", self.name self.data_raw = data print "data_raw : ", self.data_raw #print "data_raw : ", self.data_raw self.neighborhood = neighborhood self.mapshape = mapshape print "mapshape : ", self.mapshape self.initialization = initialization print "initilization : ", self.initialization self.mask = mask or np.ones([1, self._dim]) print "mask : ", self.mask self.codebook = Codebook(mapsize, lattice) print "--------codebook is a object to class Codebook---------\n", self.codebook self.training = training print "training mode : ", self.training self._component_names = self.build_component_names() print "Initial component name : ", self._component_names self._distance_matrix = self.calculate_map_dist() print "initial distance matrix : ", self._distance_matrix
def codebook(self): """ Export a code book of categories and codes. """ Codebook(self.settings, self.ui.textEdit)