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(): n, nx, ny = 100, 100, 100 m, rei = 3, 5 locs = np.random.random((n, 2))*10 ## Retrievers management ret0 = KRetriever(locs, 3, ifdistance=True) ret1 = CircRetriever(locs, .3, ifdistance=True) #countdesc = CountDescriptor() ## Other functions def map_indices(s, i): if s._pos_inputs is not None: return s._pos_inputs.start + s._pos_inputs.step*i else: return i def halting_f(signum, frame): raise Exception("Not error time.") ## Random exploration functions def random_pos_space_exploration(pos_possibles): selected, indices = [], [] for i in range(len(pos_possibles)): sel, ind = random_pos_exploration(pos_possibles[i]) selected.append(sel) indices.append(ind) return selected, indices def random_pos_exploration(possibles): ## Selection i_pos = np.random.randint(0, len(possibles)) return possibles[i_pos], i_pos ## Impossibles def impossible_instantiation(selected, p, ret, feat): i_ret, sel, agg, pert = p p_ind, m_ind, n_desc, i_feat = selected checker = False ## Not implemented perturbation over explicit features if pert is not None: if type(feat) == np.ndarray: if len(feat.shape) == 3: checker = True elif isinstance(feat, ExplicitFeatures): checker = True elif isinstance(feat, FeaturesManager): check_aux = [] for i in range(len(feat.features)): check_aux.append(isinstance(feat.features[i], ExplicitFeatures)) checker = any(check_aux) return checker def compulsary_instantiation_errors(selected, p, ret, feat): i_ret, sel, agg, pert = p p_ind, m_ind, n_desc, i_feat = selected checker = False ## Cases if p_ind == []: checker = True ## Compulsary failing instantiation if not checker: return try: boolean = False SpatialDescriptorModel(retrievers=ret, featurers=feat, mapselector_spdescriptor=sel, pos_inputs=p_ind, map_indices=m_ind, perturbations=pert, aggregations=agg, name_desc=n_desc) boolean = True except: if boolean: raise Exception("It has to halt here.") return checker def test_methods(methods, input_): """Test proper methods output for selectors indications.""" # print methods, input_ assert(len(methods) == 3) assert(methods[0] in [True, False]) if methods[1] is None: assert(methods[2] is None) elif type(input_) == int: assert(type(methods[1]) == tuple) assert(type(methods[2]) == tuple) assert(len(methods[1]) == 2) assert(len(methods[2]) == 3) assert(all([len(e) == 2 for e in methods[2]])) assert(all([type(e) == tuple for e in methods[2]])) else: assert(type(input_) == list) assert(type(methods[1]) == list) assert(type(methods[2]) == list) assert(len(methods[1]) == len(input_)) assert(len(methods[2]) == len(input_)) for i in range(len(methods[1])): assert(type(methods[1][i]) == tuple) assert(type(methods[2][i]) == tuple) assert(len(methods[1][i]) == 2) assert(len(methods[2][i]) == 3) assert(all([len(e) == 2 for e in methods[2][i]])) assert(all([type(e) == tuple for e in methods[2][i]])) ########################################################################### ########################################################################### ######## Testing aggregations preparation ## Testing all possible aggregation_in agg_f_ret = None desc_in, desc_out = AvgDescriptor(), AvgDescriptor() feats = ImplicitFeatures(np.random.random((100, 10)), descriptormodel=AvgDescriptor()) agg_in = agg_f_ret, desc_in, {}, {}, desc_out res = _parse_aggregation_feat(agg_in, feats) assert(type(res) == tuple) assert(len(res) == 5) agg_in = agg_f_ret, desc_in, {}, {} res = _parse_aggregation_feat(agg_in, feats) assert(type(res) == tuple) assert(len(res) == 5) agg_in = agg_f_ret, {}, {} res = _parse_aggregation_feat(agg_in, feats) assert(type(res) == tuple) assert(len(res) == 5) agg_in = agg_f_ret, desc_in, desc_out res = _parse_aggregation_feat(agg_in, feats) assert(type(res) == tuple) assert(len(res) == 5) agg_in = (agg_f_ret, ) res = _parse_aggregation_feat(agg_in, feats) assert(type(res) == tuple) assert(len(res) == 5) # Creation standard aggregation_info disc = GridSpatialDisc((5, 5), xlim=(0, 1), ylim=(0, 1)) locs = np.random.random((100, 2)) regs = disc.discretize(locs) disc_info = locs, regs, disc retriever_in = (KRetriever, {'info_ret': 4}) retriever_out = (KRetriever, {'info_ret': 4}) aggregating = avgregionlocs_outretriever, (avgregionlocs_outretriever, ) aggregation_info = disc_info, retriever_in, retriever_out, aggregating # Creation of aggregation objects aggretriever = create_aggretriever(aggregation_info) assert(isinstance(aggretriever, BaseRetriever)) aggfeatures = create_aggfeatures(aggregation_info, feats) assert(isinstance(aggfeatures, BaseFeatures)) ########################################################################### ########################################################################### ######## Testing instantiation spdesc ## TODO: bool_input_idx=False # Aggregation disc = GridSpatialDisc((5, 5), xlim=(0, 1), ylim=(0, 1)) retriever_in = (KRetriever, {'info_ret': 4}) retriever_out = (KRetriever, {'info_ret': 4}) aggregating = avgregionlocs_outretriever, (avgregionlocs_outretriever, ) aggregation_info = disc, retriever_in, retriever_out, aggregating # Locs and retrievers n_in, n_out = 50, 50 # TODO: Different sizes and easy manage locs_input = np.random.random((n_in, 2)) locs1 = np.random.random((n_out, 2)) locs2 = np.random.random((n_out, 2)) # Features aggfeats = np.random.random((n_out, m, rei)) featsarr0 = np.random.random((n_out, m)) featsarr1 = np.random.random((n_out, m)) featsarr2 = np.vstack([np.random.randint(0, 10, n_out) for i in range(m)]).T def new_retrievers_creation(): ret0 = KRetriever(locs1, autolocs=locs_input, info_ret=3, bool_input_idx=True) ret1 = [ret0, CircRetriever(locs2, info_ret=0.1, autolocs=locs_input, bool_input_idx=True)] ret2 = RetrieverManager(ret0) pos_rets = [ret0, ret1, ret2] return pos_rets pos_rets = range(3) ## Possible feats def new_features_creation(): feats0 = ExplicitFeatures(aggfeats) feats1 = ImplicitFeatures(featsarr0) feats2 = FeaturesManager(ExplicitFeatures(aggfeats)) pos_feats = [feats0, feats1, aggfeats, featsarr0, feats2] return pos_feats pos_feats = range(5) # Selectors arrayselector0 = np.zeros((n_in, 8)) arrayselector1 = np.zeros((n_in, 2)), np.zeros((n_in, 6)) arrayselector2 = np.zeros((n_in, 2)), tuple([np.zeros((n_in, 2))]*3) functselector0 = lambda idx: ((0, 0), ((0, 0), (0, 0), (0, 0))) functselector1 = lambda idx: (0, 0), lambda idx: ((0, 0), (0, 0), (0, 0)) tupleselector0 = (0, 0), (0, 0, 0, 0, 0, 0) tupleselector1 = (0, 0, 0, 0, 0, 0, 0, 0) tupleselector2 = (0, 0), ((0, 0), (0, 0), (0, 0)) listselector = None selobj = Sp_DescriptorSelector(*arrayselector1) pos_selectors = [None, arrayselector0, arrayselector1, arrayselector2, functselector0, functselector1, tupleselector0, tupleselector1, tupleselector2, Sp_DescriptorSelector(arrayselector0)] pos_agg = [None] ## Perturbations reindices0 = np.arange(n_out) reindices = np.vstack([reindices0]+[np.random.permutation(n_out) for i in range(rei-1)]).T perturbation = PermutationPerturbation(reindices) pos_pert = [None, perturbation] ## Random exploration pos_loop_ind = [None, 20, (0, n_in, 1), slice(0, n_in, 1), []] pos_loop_mapin = [None, map_indices] pos_name_desc = [None, '', 'random_desc'] # Possible feats # Random exploration possibilities pos_random = [pos_loop_ind, pos_loop_mapin, pos_name_desc, pos_feats] possibilities = [pos_rets, pos_selectors, pos_agg, pos_pert] s = 0 for p in product(*possibilities): i_ret, sel, agg, pert = p ## Random exploration of parameters selected, indices = random_pos_space_exploration(pos_random) p_ind, m_ind, n_desc, i_feat = selected ## Classes renewal rets_cand = new_retrievers_creation() feats_cand = new_features_creation() # Retrievers ret = rets_cand[i_ret] feat = feats_cand[i_feat] # print indices # print p, selected ## Impossible cases checker1 = impossible_instantiation(selected, p, ret, feat) checker2 = compulsary_instantiation_errors(selected, p, ret, feat) if checker1 or checker2: continue ## Testing instantiation spdesc = SpatialDescriptorModel(retrievers=ret, featurers=feat, mapselector_spdescriptor=sel, pos_inputs=p_ind, map_indices=m_ind, perturbations=pert, aggregations=agg, name_desc=n_desc) # print s #### Function testing ## Auxiliar functions spdesc.add_perturbations(pert) spdesc.set_loop(p_ind, m_ind) spdesc._map_indices(spdesc, 0) for i in spdesc.iter_indices(): methods = spdesc._get_methods(i) test_methods(methods, i) methods = spdesc._get_methods(0) test_methods(methods, 0) methods = spdesc._get_methods(10) test_methods(methods, 10) methods = spdesc._get_methods([0]) test_methods(methods, [0]) methods = spdesc._get_methods([0, 1, 2]) test_methods(methods, [0, 1, 2]) desc = spdesc._compute_descriptors(10) desc = spdesc._compute_descriptors([10]) desc = spdesc._compute_descriptors([0, 1, 2]) desc = spdesc.compute(10) desc = spdesc.compute([10]) desc = spdesc.compute([0, 1, 2]) #Retrieverdriven aux_i = 0 for desc_i, vals_i in spdesc.compute_nets_i(): assert(len(desc_i) == len(vals_i)) assert(len(desc_i) == spdesc.featurers.k_perturb+1) aux_i += 1 if aux_i == 100: break aux_i = 0 for desc_ik, vals_ik in spdesc.compute_net_ik(): aux_i += 1 if aux_i == 100: break ## Loops # for idx in spdesc.iter_indices(): # break # for vals_ik, desc_ik in spdesc.compute_net_ik(): # #assert(vals_ik) # #assert(desc_ik) # break # for desc_i, vals_i in spdesc.compute_net_i(): # #assert(vals_ik) # #assert(desc_ik) # break ## Global computations # try: # signal.signal(signal.SIGALRM, halting_f) # signal.alarm(0.01) # 0.01 seconds # spdesc.compute() # except Exception as e: # logi = e == "Not error time." # if not logi: # spdesc.compute() # try: # signal.signal(signal.SIGALRM, halting_f) # signal.alarm(0.01) # 0.01 seconds # spdesc._compute_nets() # except Exception as e: # logi = e == "Not error time." # if not logi: # spdesc._compute_nets() # try: # ## Testing compute_retdriven # signal.signal(signal.SIGALRM, halting_f) # signal.alarm(0.01) # 0.01 seconds # spdesc._compute_retdriven() # except Exception as e: # logi = e == "Not error time." # if not logi: # spdesc._compute_retdriven() # try: # logfile = Logger('logfile.log') # signal.signal(signal.SIGALRM, halting_f) # signal.alarm(0.01) # 0.01 seconds # spdesc.compute_process(logfile, lim_rows=100000, n_procs=0) # os.remove('logfile.log') # except Exception as e: # os.remove('logfile.log') # logi = e == "Not error time." # if not logi: # spdesc.compute_process(logfile, lim_rows=100000, n_procs=0) ## Testing aggregations if len(spdesc.retrievers) == len(spdesc.featurers): spdesc.add_aggregations(aggregation_info) else: spdesc.add_aggregations(aggregation_info, ([0], [0])) s += 1 feats1 = ImplicitFeatures(featsarr0) m_vals_i = np.random.randint(0, 5, 50) ret = CircRetriever(locs1, autolocs=locs_input, info_ret=3, bool_input_idx=True) feat = FeaturesManager(feats1, maps_vals_i=m_vals_i, mode='sequential', descriptormodels=None) spdesc = SpatialDescriptorModel(retrievers=ret, featurers=feat, mapselector_spdescriptor=None, perturbations=perturbation, aggregations=None, name_desc=n_desc) ## Complete processes spdesc.compute() logfile = Logger('logfile.log') spdesc.compute_process(logfile, lim_rows=100000, n_procs=0) os.remove('logfile.log') spdesc._compute_nets() spdesc._compute_retdriven() ## Model functions spdesc.fit(np.arange(20), np.random.random(20)) spdesc.predict(np.arange(20)) ############ ### Auxiliar functions #### spdesc = _spdesc_parsing_creation(ret, feat) assert(isinstance(spdesc, SpatialDescriptorModel)) res = create_aggfeatures(spdesc, None) assert(isinstance(res, ExplicitFeatures)) ########################################################################### ########################################################################### spdesc_temp = SpatioTemporalDescriptorModel(spdesc) indices = np.arange(10) y = np.random.random(10) spdesc_temp = spdesc_temp.fit(indices, y) spdesc_temp.predict(indices) spdesc_temp = SpatioTemporalDescriptorModel([spdesc, spdesc]) indices = np.arange(20) y = np.random.random(20) spdesc_temp = spdesc_temp.fit(indices, y) spdesc_temp.predict(indices)