def _format_map_vals_i(self, sp_typemodel): """Format mapper to indicate external val_i to aggregate result. Parameters ---------- sp_typemodel: list, tuple, np.ndarray the information to set the map_vals_i in order to obtain the stored index for each element. """ if sp_typemodel is not None: map_vals_i = create_mapper_vals_i(sp_typemodel, self) # if type(sp_typemodel) == tuple: # map_vals_i = create_mapper_vals_i(sp_typemodel, self) # else: # map_vals_i = create_mapper_vals_i(sp_typemodel, self) self._maps_vals_i = map_vals_i else: self._maps_vals_i = create_mapper_vals_i(self._maps_vals_i, self)
def test(): ########################################################################### ############################# Artificial data ############################# ########################################################################### ## Random relations n, density, shape = 100, 0.1, (10, 10) randint_sparse_matrix(density, shape, maxvalue=10) generate_randint_relations(density, shape, p0=0., maxvalue=1) generate_random_relations_cutoffs(n, 0.5, 0.9, True, 'network') generate_random_relations_cutoffs(n, 0.5, 0.9, False, 'network') generate_random_relations_cutoffs(n, 0.5, 0.9, True, 'sparse') n_elements, n_collections = 100, 10 random_membership(n_elements, n_collections, multiple=True) random_membership(n_elements, n_collections, multiple=False) ## Random points n_points, n_dim, funct = 100, 2, np.cos random_transformed_space_points(n_points, n_dim, funct) random_transformed_space_points(n_points, n_dim, None) random_space_points(n_points, n_dim) ## Artificial grid data create_random_image(shape, n_modes=1) create_random_image(shape, n_modes=3) ## Artificial regions n_poly = 10 random_shapely_polygon(bounding=(None, None), n_edges=0) random_shapely_polygon(bounding=((0., 1.), None), n_edges=0) random_shapely_polygon(bounding=(None, None), n_edges=4) random_shapely_polygons(n_poly, bounding=(None, None), n_edges=0) ## Artificial random features n, n_feats = np.random.randint(10, 1000), np.random.randint(2, 20) n_feats2 = [np.random.randint(2, 20) for i in range(n_feats)] ks = np.random.randint(1, 20) feats = continuous_array_features(n, n_feats) assert(len(feats.shape) == 2) feats = categorical_array_features(n, n_feats) assert(len(feats.shape) == 2) feats = categorical_array_features(n, n_feats2) assert(len(feats.shape) == 2) feats = continuous_dict_features(n, n_feats) assert(type(feats[0]) == dict) feats = categorical_dict_features(n, n_feats) assert(type(feats[0]) == dict) feats = continuous_agg_array_features(n, n_feats, ks) assert(len(feats.shape) == 3) feats = categorical_agg_array_features(n, n_feats, ks) assert(len(feats.shape) == 3) feats = categorical_agg_array_features(n, n_feats2, ks) assert(len(feats.shape) == 3) feats = continuous_agg_dict_features(n, n_feats, ks) assert(type(feats[0][0]) == dict) feats = categorical_agg_dict_features(n, n_feats, ks) assert(type(feats[0][0]) == dict) ## Artificial measures n_vals_i, n_iss = np.random.randint(2, 30), np.random.randint(1, 30) create_empty_features_array(n_feats, n_iss, ks) create_empty_features_dict(n_feats, n_iss, ks) create_features_i_array(n_feats, n_iss, ks) create_features_i_dict(n_feats, n_iss, ks) create_vals_i(n_iss, n_vals_i, ks) create_empty_array(ks, n_vals_i, n_feats) create_empty_append(ks, n_iss, n_feats) create_empty_replacelist(ks, n_iss, n_feats) create_artificial_measure_array(ks, n_vals_i, n_feats) create_artificial_measure_append(ks, n_vals_i, n_feats) create_artificial_measure_replacelist(ks, n_vals_i, n_feats) create_artificial_measure_replacelist(ks, n_vals_i, n_feats, True) ########################################################################### ############################ Spatial Elements ############################# ########################################################################### ## Parameters words = m.replace('\n', ' ').replace('.', ' ').strip().split(" ") ids = [hash(e) for e in words] functs = [lambda x: str(x)+words[i] for i in range(len(words))] regs = random_shapely_polygons(10, bounding=(None, None), n_edges=0) ## Testing Elemets words_id = np.arange(len(words)) words_elements = SpatialElementsCollection(words, words_id) words_elements2 = SpatialElementsCollection(words, list(words_id)) words_elements = SpatialElementsCollection(words) ids_elements = SpatialElementsCollection(ids) functs_elements = SpatialElementsCollection(functs) polys_elements = SpatialElementsCollection(regs, np.arange(len(regs))) # Testing error instantiation try: flag_error = False SpatialElementsCollection(0) flag_error = True raise Exception("It has to halt here.") except: if flag_error: raise Exception("It has to halt here.") try: flag_error = False SpatialElementsCollection(words, np.arange(len(words)+1)) flag_error = True raise Exception("It has to halt here.") except: if flag_error: raise Exception("It has to halt here.") try: flag_error = False tags = range(len(words)) + [len(words)-1] SpatialElementsCollection(words, tags) flag_error = True raise Exception("It has to halt here.") except: if flag_error: raise Exception("It has to halt here.") try: flag_error = False SpatialElementsCollection(words, 5) flag_error = True raise Exception("It has to halt here.") except: if flag_error: raise Exception("It has to halt here.") # Class functions words_elements[0] try: flag_error = False words_elements[len(words_elements)] flag_error = True raise Exception("It has to halt here.") except: if flag_error: raise Exception("It has to halt here.") try: flag_error = False words_elements2[words[0]] flag_error = True raise Exception("It has to halt here.") except: if flag_error: raise Exception("It has to halt here.") words_elements.elements_id = None try: flag_error = False words_elements[words[0]] flag_error = True raise Exception("It has to halt here.") except: if flag_error: raise Exception("It has to halt here.") words_elements[0] for e in words_elements: pass for e in words_elements2: pass words_elements == words[0] relabel_map = np.arange(len(words)) try: flag_error = False words_elements.relabel_elements(range(len(words))) flag_error = True except: if flag_error: raise Exception("It has to halt here.") words_elements.relabel_elements(relabel_map) relabel_map = dict(zip(relabel_map, relabel_map)) words_elements.relabel_elements(relabel_map) ids_elements[0] for e in ids_elements: pass ids_elements == words[0] functs_elements[0] for e in functs_elements: pass functs_elements == words[0] # Polygon collections polys_elements == polys_elements[0] ############################ Locations Object ############################# ########################################################################### ## Locations locs1 = np.random.random((100, 5)) locs2 = np.random.random((100, 1)) locs3 = np.random.random(100) locs4 = np.random.random((100, 2)) sptrans = lambda x, p: np.sin(x) class Translocs: def __init__(self): pass def apply_transformation(self, x, p={}): return sptrans(x, p) sptrans2 = Translocs() lspcol = SpatialElementsCollection(locs1, np.arange(len(locs1))) lspcol == lspcol[0] try: flag_error = False locs = Locations(locs1, 5) flag_error = True raise Exception("It has to halt here.") except: if flag_error: raise Exception("It has to halt here.") try: flag_error = False locs = Locations(locs1, list(range(len(locs1)+1))) flag_error = True raise Exception("It has to halt here.") except: if flag_error: raise Exception("It has to halt here.") try: flag_error = False tags = list(range(len(locs1))) tags[0] = 1 locs = Locations(locs1, tags) flag_error = True raise Exception("It has to halt here.") except: if flag_error: raise Exception("It has to halt here.") locs = Locations(locs1) locsbis = Locations(locs1, list(range(len(locs1)))) for l in locs: pass try: flag_error = False locs[-1] flag_error = True raise Exception("It has to halt here.") except: if flag_error: raise Exception("It has to halt here.") try: flag_error = False locsbis[slice(0, 9)] flag_error = True raise Exception("It has to halt here.") except: if flag_error: raise Exception("It has to halt here.") locsbis[0] locs[0] assert((locs == locs1[0])[0]) locs.compute_distance(locs[1]) locs.space_transformation(sptrans, {}) locs.space_transformation(sptrans2, {}) locs._check_coord(0) locs._check_coord(locs[0]) locs._check_coord([0, 3]) locs._check_coord(np.random.random(locs.locations.shape[1])) locs._check_coord([locs1[0], locs1[3]]) locs._check_coord(None) locs.in_radio(locs[0], 0.2) locs.data locs = Locations(locs2) assert((locs == locs2[0])[0]) locs.compute_distance(locs[1]) locs.space_transformation(sptrans, {}) locs.space_transformation(sptrans2, {}) locs.in_manhattan_d(locs[0], 0.2) locs = Locations(locs3) assert((locs == locs3[0])[0]) locs.compute_distance(locs[1]) locs.space_transformation(sptrans, {}) locs.space_transformation(sptrans2, {}) locs = Locations(locs4) locs.in_block_distance_d(np.random.random((1, 2)), 0.2) ########################################################################### ############################### Membership ################################ ########################################################################### # artificial data random_membership(10, 20, True) random_membership(10, 20, False) n_in, n_out = 100, 20 relations = [np.unique(np.random.randint(0, n_out, np.random.randint(n_out))) for i in range(n_in)] relations = [list(e) for e in relations] memb1 = Membership(relations) memb1.to_network() memb1.to_dict() memb1.to_sparse() memb1.reverse_mapping() memb1.getcollection(0) memb1.getcollection(memb1.max_collection_id-1) memb1.collections_id memb1.n_collections memb1.n_elements memb1.membership str(memb1) memb1[0] memb1 == 0 for e in memb1: pass # op2 = np.all([t == dict for t in types]) relations = [dict(zip(e, len(e)*[{'membership': 1}])) for e in relations] memb1_dict = Membership(relations) memb1_dict.to_network() memb1_dict.to_dict() memb1_dict.to_sparse() memb1_dict.reverse_mapping() memb1_dict.getcollection(0) memb1.getcollection(memb1.max_collection_id-1) memb1_dict.collections_id memb1_dict.n_collections memb1_dict.n_elements memb1_dict.membership memb1.shape memb1.max_collection_id memb2 = Membership(np.random.randint(0, 20, 100)) memb2.to_network() memb2.to_dict() memb2.to_sparse() memb2.reverse_mapping() memb2.getcollection(0) memb2.getcollection(memb2.max_collection_id-1) memb2.collections_id memb2.n_collections memb2.n_elements memb2.membership str(memb2) memb2[0] memb2 == 0 for e in memb2: pass memb2.shape memb2.max_collection_id sparse = randint_sparse_matrix(0.2, (200, 100), 1) memb3 = Membership(sparse) memb3.to_dict() memb3.to_network() memb3.to_sparse() memb3.reverse_mapping() memb3.getcollection(0) memb3.getcollection(memb3.max_collection_id-1) memb3.collections_id memb3.n_collections memb3.n_elements memb3.membership str(memb3) memb3[0] memb3 == 0 for e in memb3: pass memb3.shape memb3.max_collection_id relations = [[np.random.randint(10)] for i in range(50)] memb4 = Membership(relations) memb4.to_network() memb4.to_dict() memb4.to_sparse() memb4.reverse_mapping() memb4.getcollection(0) memb4.getcollection(memb4.max_collection_id-1) memb4.collections_id memb4.n_collections memb4.n_elements memb4.membership str(memb4) memb4[0] memb4 == 0 for e in memb4: pass memb4.shape memb4.max_collection_id relations[0].append(0) memb5 = Membership(relations) memb5.to_network() memb5.to_dict() memb5.to_sparse() memb5.reverse_mapping() memb5.getcollection(0) memb5.getcollection(memb5.max_collection_id-1) memb5.collections_id memb5.n_collections memb5.n_elements memb5.membership str(memb5) memb5[0] memb5 == 0 for e in memb5: pass memb5.shape memb5.max_collection_id relations[0].append(0) memb6 = Membership((sparse, np.arange(100))) memb6.to_network() memb6.to_dict() memb6.to_sparse() memb6.reverse_mapping() memb6.getcollection(0) memb6.getcollection(memb6.max_collection_id-1) memb6.collections_id memb6.n_collections memb6.n_elements memb6.membership str(memb6) memb6[0] memb6 == 0 for e in memb6: pass memb6.shape memb6.max_collection_id ########################################################################### ############################### Mapper vals ############################### ########################################################################### feat_arr0 = np.random.randint(0, 20, 100) def map_vals_i_t(s, i, k): k_p, k_i = s.features[0]._map_perturb(k) i_n = s.features[0]._perturbators[k_p].apply2indice(i, k_i) return feat_arr0[i_n].ravel()[0] map_vals_i = create_mapper_vals_i(map_vals_i_t, feat_arr0) # correlation map_vals_i = create_mapper_vals_i('correlation', feat_arr0) map_vals_i = create_mapper_vals_i(('correlation', 100, 20), feat_arr0) map_vals_i = create_mapper_vals_i('matrix') map_vals_i = create_mapper_vals_i('matrix', feat_arr0) map_vals_i = create_mapper_vals_i('matrix', feat_arr0.reshape((100, 1))) map_vals_i = create_mapper_vals_i(('matrix', 20), list(feat_arr0)) map_vals_i = create_mapper_vals_i(('matrix', 100, 20), len(feat_arr0)) map_vals_i = create_mapper_vals_i('matrix', slice(0, 100, 1)) map_vals_i.set_prefilter(slice(0, 100, 1)) map_vals_i.set_prefilter(10) map_vals_i.set_prefilter([0, 2]) map_vals_i.set_sptype('correlation') map_vals_i[(None, [0], 0)] map_vals_i.apply(None, [0], 0) map_vals_i = create_mapper_vals_i(map_vals_i) map_vals_i = create_mapper_vals_i(feat_arr0.reshape(100, 1)) map_vals_i = create_mapper_vals_i(None) map_vals_i = Map_Vals_i(100) map_vals_i = Map_Vals_i((1000, 20)) map_vals_i = Map_Vals_i(map_vals_i) map_vals_i = Map_Vals_i(memb1) ## Stress testing try: boolean = False map_vals_i = create_mapper_vals_i('correlation') boolean = True raise Exception("It has to halt here.") except: if boolean: raise Exception("The test has to halt here.") ########################################################################### ############################## Spdesc_mapper ############################## ########################################################################### #selector1 = Sp_DescriptorMapper() mapper_array = np.random.randint(0, 5, 100) mapper_function = lambda idx: mapper_array[idx] mapper_function1 = lambda idx: tuple([mapper_array[idx]]*2) pos_mappers = [{'mapper': mapper_array}, {'mapper': mapper_function}, {'mapper': mapper_function, 'compute': True}, {'mapper': mapper_function, 'n_in': 5, 'n_out': 6}, {'mapper': mapper_function1, 'n_in': 5, 'n_out': [3, 4]}, {'mapper': mapper_function1, 'n_in': 5, 'compute': True}] for p in pos_mappers: comb_selector = DummySelector(**p) # comb_selector = GeneralSelector(**p) comb_selector[0] # Impossible cases try: ## Non-integer key getitem boolean = False map_vals_i = comb_selector[.2] boolean = True raise Exception("It has to halt here.") except: if boolean: raise Exception("The test has to halt here.") ## Functions DummySelector(comb_selector) comb_selector[0] comb_selector.set_pars(2, lambda x: (0, 0), n_out=[1, 1]) comb_selector[0] selector1 = DummySelector(mapper_array) selector2 = DummySelector(lambda idx: mapper_array[idx], n_in=100, n_out=3) selector3 = DummySelector(lambda idx: [mapper_array[idx]]*3, n_in=100) sl = BaseCollectionSelectors([selector1, selector2, selector3]) # Spatial retriever selector sel = Spatial_RetrieverSelector(np.array([mapper_array]*2).T) sel[0], sel[0, 1], sel[[0, 1]] sel = Spatial_RetrieverSelector(mapper_array, mapper_array) sel[0], sel[0, 1], sel[[0, 1]] sel = Spatial_RetrieverSelector(mapper_function1) sel[0], sel[0, 1], sel[[0, 1]] sel = Spatial_RetrieverSelector(mapper_function, mapper_function) sel[0], sel[0, 1], sel[[0, 1]] sel = Spatial_RetrieverSelector(sel) sel[0], sel[0, 1], sel[[0, 1]] sel = Spatial_RetrieverSelector((0, 0)) sel[0], sel[0, 1], sel[[0, 1]] sel = Spatial_RetrieverSelector(0, 0) sel[0], sel[0, 1], sel[[0, 1]] try: ## Different types of core mappers boolean = False Spatial_RetrieverSelector(mapper_array, mapper_function) boolean = True raise Exception("It has to halt here.") except: if boolean: raise Exception("The test has to halt here.") try: ## Not correct shape boolean = False Spatial_RetrieverSelector(mapper_array) boolean = True raise Exception("It has to halt here.") except: if boolean: raise Exception("The test has to halt here.") # FeatureInd retriever selector sel = FeatInd_RetrieverSelector(np.array([mapper_array]*2).T) sel[0], sel[0, 1], sel[[0, 1]] sel = FeatInd_RetrieverSelector(mapper_array, mapper_array) sel[0], sel[0, 1], sel[[0, 1]] sel = FeatInd_RetrieverSelector(mapper_function1) sel[0], sel[0, 1], sel[[0, 1]] sel = FeatInd_RetrieverSelector(mapper_function, mapper_function) sel[0], sel[0, 1], sel[[0, 1]] sel = FeatInd_RetrieverSelector(sel) sel[0], sel[0, 1], sel[[0, 1]] sel = FeatInd_RetrieverSelector((0, 0)) sel[0], sel[0, 1], sel[[0, 1]] sel = FeatInd_RetrieverSelector(0, 0) sel[0], sel[0, 1], sel[[0, 1]] try: ## Different types of core mappers boolean = False FeatInd_RetrieverSelector(mapper_array, mapper_function) boolean = True raise Exception("It has to halt here.") except: if boolean: raise Exception("The test has to halt here.") try: ## Different types of core mappers boolean = False FeatInd_RetrieverSelector(np.array([mapper_array]*10).T) boolean = True raise Exception("It has to halt here.") except: if boolean: raise Exception("The test has to halt here.") # FeatureInd retriever selector sel = Desc_RetrieverSelector(np.array([mapper_array]*2).T) sel[0], sel[0, 1], sel[[0, 1]] sel = Desc_RetrieverSelector(mapper_array, mapper_array) sel[0], sel[0, 1], sel[[0, 1]] sel = Desc_RetrieverSelector(mapper_function1) sel[0], sel[0, 1], sel[[0, 1]] sel = Desc_RetrieverSelector(mapper_function, mapper_function) sel[0], sel[0, 1], sel[[0, 1]] sel = Desc_RetrieverSelector(sel) sel[0], sel[0, 1], sel[[0, 1]] sel = Desc_RetrieverSelector((0, 0)) sel[0], sel[0, 1], sel[[0, 1]] sel = Desc_RetrieverSelector(0, 0) sel[0], sel[0, 1], sel[[0, 1]] try: ## Different types of core mappers boolean = False Desc_RetrieverSelector(mapper_array, mapper_function) boolean = True raise Exception("It has to halt here.") except: if boolean: raise Exception("The test has to halt here.") try: ## Different types of core mappers boolean = False Desc_RetrieverSelector(np.array([mapper_array]*10).T) boolean = True raise Exception("It has to halt here.") except: if boolean: raise Exception("The test has to halt here.") # FeatureInd retriever selector pos_selt = [(np.array([mapper_array]*2).T, ), (mapper_array, mapper_array), (mapper_function1, ), (mapper_function, mapper_function)] def test_getitem(selector): selector[0] selector[0, 1] selector[[0, 1]] try: boolean = False selector[0.7] boolean = True except: if boolean: raise Exception("It has to halt here.") for i in range(len(pos_selt)): ## Instantiation sel0 = Spatial_RetrieverSelector(*pos_selt[i]) sel1 = FeatInd_RetrieverSelector(*pos_selt[i]) sel2 = FeatInd_RetrieverSelector(*pos_selt[i]) sel3 = Desc_RetrieverSelector(*pos_selt[i]) selfeat = Feat_RetrieverSelector(sel1, sel2, sel3) test_getitem(selfeat) ## Partial information instantiation selfeat = Feat_RetrieverSelector(selfeat, None, None) test_getitem(selfeat) ### Testing Sp_DescriptorSelector sel = Sp_DescriptorSelector(sel0, selfeat) test_getitem(sel) ### Testing Sp_DescriptorSelector with partial instantiation sel = Sp_DescriptorSelector(sel) test_getitem(sel) #### Individual tests ## Partial information instantiation selfeat = Feat_RetrieverSelector((0, 0, 0, 0, 0, 0), None, None) # Getitem test_getitem(selfeat) # ## Partial information instantiation ## Instantiation sel1 = FeatInd_RetrieverSelector(sel1) sel2 = FeatInd_RetrieverSelector(sel2) sel3 = Desc_RetrieverSelector(sel3) selfeat = Feat_RetrieverSelector(sel1, sel2, sel3) test_getitem(selfeat) selfeat = Feat_RetrieverSelector(np.zeros((100, 6))) test_getitem(selfeat) selfeat = Feat_RetrieverSelector((lambda idx: (0, 0, 0, 0, 0, 0), {'n_in': 200})) test_getitem(selfeat)
def relative_descriptors(self, i, neighs_info, desc_i, desc_neigh, vals_i): "General default relative descriptors." descriptors = desc_i[:] ind_life = desc_i.ravel().astype(bool) ind_dead = np.logical_not(desc_i.ravel()) descriptors[ind_life] = np.logical_or(desc_neigh[ind_life] == 2, desc_neigh[ind_life] == 3) descriptors[ind_dead] = desc_neigh[ind_dead] == 3 return descriptors if __name__ == "__main__": ## Initial variables nx, ny, nt = 10, 10, 100 pars_ret = {'l': 3, 'center': 0, 'excluded': True} ## Initialization initial_state = np.random.randint(0, 2, nx*ny) windret = WindowsRetriever((nx, ny), pars_ret=pars_ret) gret = RetrieverManager(windret) conw_ev = ConwayEvolution() ## Evolution state = initial_state[:] m_vals_i = create_mapper_vals_i(('matrix', len(state), len(state))) for i in range(nt): state =\ FeaturesManager(ImplicitFeatures(state, descriptormodel=conw_ev), maps_vals_i=m_vals_i) spdesc = SpatialDescriptorModel(gret, state) state = spdesc.compute()[:, :, 0].astype(int)