def test():
### Parameters or externals
info_ret = {'order': 2}
locs = np.random.random((1000, 2))
inttypes = [int, np.int32, np.int64]
# mainmapper1 = generate_random_relations(25, store='sparse')
# mainmapper2 = generate_random_relations(100, store='sparse')
# mainmapper3 = generate_random_relations(5000, store='sparse')
griddisc1 = GridSpatialDisc((5, 5), xlim=(0, 1), ylim=(0, 1))
griddisc2 = GridSpatialDisc((10, 10), xlim=(0, 1), ylim=(0, 1))
griddisc3 = GridSpatialDisc((50, 100), xlim=(0, 1), ylim=(0, 1))
### Testing utities
## util_spatial_relations
f = lambda x, y: x + y
sp_elements = np.random.random(10)
general_spatial_relation(sp_elements[0], sp_elements[0], f)
general_spatial_relations(sp_elements, f, simmetry=False)
general_spatial_relations(sp_elements, f, simmetry=True)
## format_out_relations
mainmapper1 = randint_sparse_matrix(0.8, (25, 25))
format_out_relations(mainmapper1, 'sparse')
format_out_relations(mainmapper1, 'network')
format_out_relations(mainmapper1, 'sp_relations')
lista = format_out_relations(mainmapper1, 'list')
u_regs = mainmapper1.data
## Element metrics
element_i, element_j = 54, 2
pars1 = {'periodic': 60}
pars2 = {}
unidimensional_periodic(element_i, element_j, pars=pars1)
unidimensional_periodic(element_i, element_j, pars=pars2)
unidimensional_periodic(element_j, element_i, pars=pars1)
unidimensional_periodic(element_j, element_i, pars=pars2)
measure_difference(element_i, element_j, pars=pars1)
measure_difference(element_i, element_j, pars=pars2)
measure_difference(element_j, element_i, pars=pars1)
measure_difference(element_j, element_i, pars=pars2)
def ensure_output(neighs, dists, mainmapper):
# print dists
assert(all([len(e.shape) == 2 for e in dists]))
assert(all([len(e) == 0 for e in dists if np.prod(e.shape) == 0]))
if mainmapper._out == 'indices':
# print neighs
correcness = []
for nei in neighs:
if len(nei):
correcness.append(all([type(e) in inttypes for e in nei]))
else:
correcness.append(nei.dtype in inttypes)
assert(correcness)
###########################################################################
### Massive combinatorial testing
# Possible parameters
relations, pars_rel, _data =\
compute_ContiguityRegionDistances(griddisc1, store='sparse')
pos_relations = [relations, relations.A,
format_out_relations(relations, 'network')]
pos_distanceorweighs, pos_sym = [True, False], [True, False]
pos_inputstypes, pos_outputtypes = [[None, 'indices', 'elements_id']]*2
pos_input_type = [None, 'general', 'integer', 'array', 'array1', 'array2',
'list', 'list_int', 'list_array']
pos_inputs = [[0], 0, 0, np.array([0]), np.array([0]), np.array([0]),
[0], [0], [np.array([0])]]
pos_data_in, pos_data = [[]]*2
possibles = [pos_relations, pos_distanceorweighs, pos_sym, pos_outputtypes,
pos_inputstypes, pos_input_type]
# Combinations
for p in product(*possibles):
mainmapper1 = RegionDistances(relations=p[0], distanceorweighs=p[1],
symmetric=p[2], output=p[3], input_=p[4],
input_type=p[5])
mainmapper1[slice(0, 1)]
# Define input
if p[5] is None:
if p[4] != 'indices':
neighs, dists = mainmapper1[mainmapper1.data[0]]
ensure_output(neighs, dists, mainmapper1)
neighs, dists = mainmapper1[0]
ensure_output(neighs, dists, mainmapper1)
neighs, dists = mainmapper1[np.array([-1])]
ensure_output(neighs, dists, mainmapper1)
if p[4] != 'elements_id':
neighs, dists = mainmapper1[0]
ensure_output(neighs, dists, mainmapper1)
try:
boolean = False
mainmapper1[-1]
boolean = True
raise Exception("It has to halt here.")
except:
if boolean:
raise Exception("It has to halt here.")
else:
if p[5] == 'list':
# Get item
neighs, dists = mainmapper1[[0]]
ensure_output(neighs, dists, mainmapper1)
neighs, dists = mainmapper1[[np.array([0])]]
ensure_output(neighs, dists, mainmapper1)
try:
boolean = False
mainmapper1[[None]]
boolean = True
raise Exception("It has to halt here.")
except:
if boolean:
raise Exception("It has to halt here.")
idxs = pos_inputs[pos_input_type.index(p[5])]
neighs, dists = mainmapper1[idxs]
ensure_output(neighs, dists, mainmapper1)
# Functions
mainmapper1.set_inout(p[5], p[4], p[3])
mainmapper1.transform(lambda x: x)
mainmapper1.data
mainmapper1.data_input
mainmapper1.data_output
mainmapper1.shape
## Extreme cases
## Individual extreme cases
## Instantiation
pars_rel = {'symmetric': False}
relations = relations.A
data_in = list(np.arange(len(relations)))
wrond_data = np.random.random((100))
mainmapper3 = RegionDistances(relations=relations, _data=wrond_data,
data_in=data_in, **pars_rel)
data_in = np.arange(len(relations)).reshape((len(relations), 1))
mainmapper3 = RegionDistances(relations=relations, _data=wrond_data,
data_in=data_in, **pars_rel)
try:
boolean = False
wrond_data = np.random.random((100, 3, 4))
mainmapper3 = RegionDistances(relations=relations, _data=wrond_data,
data_in=data_in, **pars_rel)
boolean = True
raise Exception("It has to halt here.")
except:
if boolean:
raise Exception("It has to halt here.")
try:
boolean = False
wrond_data = np.random.random((100, 3, 4))
sparse_rels = randint_sparse_matrix(0.8, (25, 25))
mainmapper3 = RegionDistances(relations=relations, _data=wrond_data,
data_in=data_in, **pars_rel)
boolean = True
raise Exception("It has to halt here.")
except:
if boolean:
raise Exception("It has to halt here.")
try:
boolean = False
wrond_data = np.random.random((100, 3, 4))
mainmapper3 = RegionDistances(relations=relations, _data=wrond_data,
data_in=data_in, **pars_rel)
boolean = True
raise Exception("It has to halt here.")
except:
if boolean:
raise Exception("It has to halt here.")
relations = np.random.random((20, 20))
try:
boolean = False
wrond_data = np.random.random((100, 3, 4))
mainmapper3 = RegionDistances(relations=relations, _data=wrond_data,
data_in=data_in, **pars_rel)
boolean = True
raise Exception("It has to halt here.")
except:
if boolean:
raise Exception("It has to halt here.")
## Other cases
# Dummymap instantiation
regs0 = np.unique(np.random.randint(0, 1000, 200))
regs1 = regs0.reshape((len(regs0), 1))
regs2 = regs0.reshape((len(regs0), 1, 1))
pos_regs = [regs0, list(regs0), regs1]
possibles = [pos_regs, pos_input_type]
for p in product(*possibles):
dummymapper = DummyRegDistance(p[0], p[1])
# Get item
idxs = pos_inputs[pos_input_type.index(p[1])]
neighs, dists = dummymapper[idxs]
ensure_output(neighs, dists, dummymapper)
neighs, dists = dummymapper[slice(0, 1)]
ensure_output(neighs, dists, dummymapper)
## Functions
dummymapper.transform(lambda x: x)
dummymapper.data
dummymapper.data_input
dummymapper.data_output
dummymapper.shape
# Halting cases
try:
boolean = False
dummymapper = DummyRegDistance(regs2)
boolean = True
raise Exception("It has to halt here.")
except:
if boolean:
raise Exception("It has to halt here.")
try:
boolean = False
dummymapper = DummyRegDistance(None)
boolean = True
raise Exception("It has to halt here.")
except:
if boolean:
raise Exception("It has to halt here.")
try:
boolean = False
dummymapper[None]
boolean = True
raise Exception("It has to halt here.")
except:
if boolean:
raise Exception("It has to halt here.")
try:
boolean = False
dummymapper[-1]
boolean = True
raise Exception("It has to halt here.")
except:
if boolean:
raise Exception("It has to halt here.")
###########################################################################
### Auxiliar parsing creation functions test
############################################
# Standarts
# * relations object
# * (main_relations_info, pars_rel)
# * (main_relations_info, pars_rel, _data)
# * (main_relations_info, pars_rel, _data, data_in)
#
## Main relations information
relations = np.random.random((100, 20))
_data = np.arange(20)
_data_input = np.arange(100)
relations_info = (relations, {})
relations_object = _relations_parsing_creation(relations_info)
assert(isinstance(relations_object, RegionDistances))
relations_info = (relations, {}, _data)
relations_object = _relations_parsing_creation(relations_info)
assert(isinstance(relations_object, RegionDistances))
relations_info = (relations, {}, _data, _data_input)
relations_object = _relations_parsing_creation(relations_info)
assert(isinstance(relations_object, RegionDistances))
relations_object = _relations_parsing_creation(relations_object)
assert(isinstance(relations_object, RegionDistances))
relations_object = _relations_parsing_creation(relations)
assert(isinstance(relations_object, RegionDistances))
###########################################################################
### Computers testing
#####################
## aux_regionmetrics
# Get regions activated
elements = griddisc1.get_regions_id()
get_regions4distances(griddisc1, elements=None, activated=None)
get_regions4distances(griddisc1, elements, activated=elements)
# Filter possible neighs
only_possible = np.unique(np.random.randint(0, 100, 50))
neighs = [np.unique(np.random.randint(0, 100, 6)) for i in range(4)]
dists = [np.random.random(len(neighs[i])) for i in range(4)]
filter_possible_neighs(only_possible, neighs, dists)
filter_possible_neighs(only_possible, neighs, None)
# TODO: Sync with other classes as sp_desc_models
lista = [[0, 1, 2, 3], [0, 2, 3, 5], [1, 1, 1, 1]]
u_regs = np.arange(25)
regions_id = np.arange(25)
elements_i = np.arange(25)
element_labels = np.arange(25)
discretizor = GridSpatialDisc((5, 5), xlim=(0, 1), ylim=(0, 1))
locs = np.random.random((100, 2))
retriever = KRetriever
info_ret = np.ones(100)*4
descriptormodel = DummyDescriptor()
sp_descriptor = discretizor, locs, retriever, info_ret, descriptormodel
sparse_from_listaregneighs(lista, u_regs, symmetric=True)
sparse_from_listaregneighs(lista, u_regs, symmetric=False)
ret_selfdists = KRetriever(locs, 4, ifdistance=True)
compute_selfdistances(ret_selfdists, np.arange(100), typeoutput='network',
symmetric=True)
compute_selfdistances(ret_selfdists, np.arange(100), typeoutput='sparse',
symmetric=True)
compute_selfdistances(ret_selfdists, np.arange(100), typeoutput='matrix',
symmetric=True)
# create_sp_descriptor_points_regs(sp_descriptor, regions_id, elements_i)
# create_sp_descriptor_regionlocs(sp_descriptor, regions_id, elements_i)
## Compute Avg distance
locs = np.random.random((100, 2))
sp_descriptor = (griddisc1, locs), (KRetriever, {'info_ret': 5}), None
relations, pars_rel, _data =\
compute_AvgDistanceRegions(sp_descriptor, store='network')
regdists = RegionDistances(relations=relations, _data=_data, **pars_rel)
relations, pars_rel, _data =\
compute_AvgDistanceRegions(sp_descriptor, store='matrix')
regdists = RegionDistances(relations=relations, _data=_data, **pars_rel)
relations, pars_rel, _data =\
compute_AvgDistanceRegions(sp_descriptor, store='sparse')
regdists = RegionDistances(relations=relations, _data=_data, **pars_rel)
# Region spatial relations
# For future (TODO)
### RegionDistances Computers
griddisc1 = GridSpatialDisc((5, 5), xlim=(0, 1), ylim=(0, 1))
## Compute Contiguity
relations, pars_rel, _data =\
compute_ContiguityRegionDistances(griddisc1, store='matrix')
relations, pars_rel, _data =\
compute_ContiguityRegionDistances(griddisc1, store='network')
relations, pars_rel, _data =\
compute_ContiguityRegionDistances(griddisc1, store='sparse')
mainmapper1 = RegionDistances(relations=relations, _data=None,
**pars_rel)
neighs, dists = mainmapper1.retrieve_neighs([0])
assert(len(neighs) == len(dists))
assert(len(neighs) == 1)
neighs, dists = mainmapper1.retrieve_neighs([0, 1])
assert(len(neighs) == len(dists))
assert(len(neighs) == 2)
## Compute CenterLocs
sp_descriptor = griddisc1, None, None
## TODO: pdist problem
relations, pars_rel, _data =\
compute_CenterLocsRegionDistances(sp_descriptor, store='network',
elements=None, symmetric=True,
activated=None)
relations, pars_rel, _data =\
compute_CenterLocsRegionDistances(sp_descriptor, store='matrix',
elements=None, symmetric=True,
activated=None)
relations, pars_rel, _data =\
compute_CenterLocsRegionDistances(sp_descriptor, store='sparse',
elements=None, symmetric=True,
activated=None)
sp_descriptor = griddisc1, (KRetriever, {'info_ret': 2}), None
### TODO: Descriptormodel
relations, pars_rel, _data =\
compute_CenterLocsRegionDistances(sp_descriptor, store='sparse',
elements=None, symmetric=True,
activated=None)
## Retriever tuple
## Retriever object
## Spdesc
## Compute PointsNeighsIntersection
## Aux_regionmetrics
#sparse_from_listaregneighs(lista, u_regs, symmetric)
###########################################################################
### Relative positioner testing
###############################
n_el, n_dim = 5, 2
elements_i = np.random.random((n_el, n_dim))
elements_neighs = []
for i in range(n_el):
aux_neigh = np.random.random((np.random.randint(1, 4), n_dim))
elements_neighs.append(aux_neigh)
rel_pos = BaseRelativePositioner(metric_distances)
rel_pos.compute(elements_i, elements_neighs)
rel_pos = BaseRelativePositioner(diff_vectors)
rel_pos.compute(elements_i, elements_neighs)
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)
