def changeFromSegmentsToRows(segmentCsp): rowCsp = CSP() for row in range(numberOfRows): variable = LineSegment(row, -1) rowCsp.variables.append(variable) rowCsp.constraints[variable] = [] for col in range(numberOfColumns): variable = LineSegment(-1, col) rowCsp.variables.append(variable) rowCsp.constraints[variable] = [] # Add rows as variables to CSP for row in range(numberOfRows): rowCsp.domains[rowCsp.variables[row]] = [] # Add columns as variables to CSP for col in range(numberOfColumns): rowCsp.domains[rowCsp.variables[numberOfRows + col]] = [] # Add domain to rowCsp addDomains(segmentCsp, rowCsp) # Add constraints to rowCsp addConstraints(rowCsp) return rowCsp
def backtrackSearch( csp_i: CSP, assignment_i: Assignment = None) -> Optional[Assignment]: """ Executes backtracking search for a complete assignment of a csp :param csp_i: csp of interest :param assignment_i: eventual partial assignment to respect :return: assignment if it exist, None otherwise """ if assignment_i is None: # if it's the init call, we run AC-3 and we initialize an assignment if not AC3(csp_i): return None assignment_i = Assignment() if len(assignment_i.getAssignment()) == csp_i.countVariables( ): # if the assignment is complete, we can return it return assignment_i var = orderVariables(csp_i, assignment_i) values = orderDomainValues(csp_i, assignment_i, var) for value in values: localAssignment = copy( assignment_i ) # we try to assign a var in a local copy of assignment localAssignment.addVarAssigned(var, value) if MAC( csp_i, localAssignment, csp_i.getNeighbour(var) ): # if it's possible to complete the assignment, we iterate... result = backtrackSearch(csp_i, localAssignment) if result is not None: # ... if it fails, we go back and propagate the None result return result # if the recursion arrive to a None, we don't want to propagate it, but we want to try next value return None
def batch(): x, y = CSP.load_data() kv = BCI.gen_kv_idx(y, 10) for train_idx, test_idx in kv: x_train, y_train = x[train_idx], y[train_idx] x_test, y_test = x[test_idx], y[test_idx] fb_mi = fb_mibif(x_train, y_train) #ts_mi = ts_mibif(x_train, y_train) fb_idx = np.argmax(fb_mi) #ts_idx = np.argmax(ts_mi) fb_csp = CSP.filterbank_CSP(x_train) #ts_csp = CSP.temporal_spectral_CSP(x_train) fb_x = mi_selector(fb_csp, fb_idx) ts_x = mi_selector(ts_csp, fb_idx) from sklearn.discriminant_analysis import LinearDiscriminantAnalysis fb_lda = LinearDiscriminantAnalysis(solver='lsqr', shrinkage='auto') ts_lda = LinearDiscriminantAnalysis(solver='lsqr', shrinkage='auto') fb_lda.fit(fb_x, y_train) ts_lad.fit(ts_x, y_train) fb_x_t = mi_selector(CSP.filterbank_CSP(x_test), fb_x) #ts_x_t = mi_selector(CSP.temporal_spectral_CSP(x_test), ts_mi) fb_score = fb_lda.score(fb_x_t, y_test) ts_score = ts_lda.score(ts_x_t, y_test) print(fb_score) print(ts_score)
def tree_csp_solver(problem, nodeList, matrix): Ass = [] j = random.randrange(0, len(nodeList)) root = nodeList[j] Functions.DAC(problem, nodeList, matrix) n = 0 for u in nodeList: d = Node.Node.getDomain(u) if (len(d) == 0): return False mx = matrix ts = Functions.TopSort(mx, j) NL = [] print "\n Ordine:" for j in ts: print ts[j], for i in ts: k = ts[i] node = nodeList[k] NL.append(node) print "\n", NL for u in NL: if (u.color == 0): kappa = nodeList.index(u) CSP.assignment(NL, matrix, u, kappa) ass = Node.Node.getColor(u) Ass.append(ass) else: Ass.append(u.color) print Ass return Ass
def arrange(self, event): self.frame_body.pack_forget() self.frame_body = Frame(self.frame) self.csp = None self.list_of_jadwal_ruangan = [] self.list_of_jadwal_kegiatan = [] self.csp = CSP(self.dasbor.entry_nama_file.get()) if self.pilihan_algoritma.get() == 0: schedule = Schedule() hill = HillClimbing() hill.algorithm(schedule, self.csp, int(self.dasbor.entry_iterasi_maksimal.get())) elif self.pilihan_algoritma.get() == 1: Schedule1 = Schedule() Schedule1.inisialisasi(self.csp) SimulatedAnnealing1 = SimulatedAnnealing(float(self.dasbor.entry_T.get()), float(self.dasbor.entry_Tmin.get()), float(self.dasbor.entry_alpha.get())) SimulatedAnnealing1.inisialisasi(Schedule1, self.csp) elif self.pilihan_algoritma.get() == 2: for i in range(int(self.dasbor.entry_iterasi_maksimal.get())): PopulasiGA1 = PopulasiGA() PopulasiGA1.isiPopulasi(self.csp.getListOfJadwal(), self.csp.getListOfRuangan()) PopulasiGA1.selection() PopulasiGA1.crossOver() PopulasiGA1.mutasi(self.csp) konflikMinimal, idxMinimal = PopulasiGA1.cekKonflikPopulasi() self.csp.setJumlahConflict2(konflikMinimal) if (konflikMinimal == 0): break PopulasiGA1.assignToCSP(PopulasiGA1.getIndividuByIndex(idxMinimal), self.csp) self.dasbor.label_angka_jadwal_bentrok.config(text=str(self.csp.getJumlahConflict2())) self.dasbor.label_angka_persentase.config(text=str(self.csp.hitungEfisiensi()*100)+'%') for ruangan in self.csp.getListOfRuangan(): self.list_of_jadwal_ruangan.append(JadwalRuangan(self.frame_body, ruangan)) for kegiatan in self.csp.getListOfJadwal(): self.list_of_jadwal_kegiatan.append(JadwalKegiatan(self.list_of_jadwal_ruangan, kegiatan)) #BINDING for jadwal_ruangan in self.list_of_jadwal_ruangan: for index_baris in range (2,13): for index_kolom in range (1,6): frame_jadwal_ruangan = jadwal_ruangan.matrix_of_frame_jadwal_ruangan[index_baris][index_kolom] frame_jadwal_ruangan.bind('<Button-1>', lambda event, a=jadwal_ruangan, b=index_baris, c=index_kolom: self.pindah_jadwal(a,b,c)) for jadwal_kegiatan in self.list_of_jadwal_kegiatan: for button in jadwal_kegiatan.list_of_button: button.bind('<Button-1>', lambda event, a=button.cget('text'), b=jadwal_kegiatan: self.pilih_kegiatan(a,b)) #SHOW for jadwal_ruangan in self.list_of_jadwal_ruangan: jadwal_ruangan.show() for jadwal_kegiatan in self.list_of_jadwal_kegiatan: jadwal_kegiatan.show() self.frame_body.pack(side=TOP, expand=True)
def allSolutions( csp: CSP, *, count: bool = False, assignment: Assignment = None, solutions: Union[List[Assignment], int] = None ) -> Union[List[Assignment], int]: """ Executes a modified backtracking search for all complete assignment of a csp. Execution time: Theta(n^d) d=max cardinality. ONLY FOR TEST PURPOSE :param count: if you want only count the number of solution set it to True :param csp: csp of interest :param assignment: eventual partial assignment to respect :param solutions: eventual already found solutions :return: assignment if it exist, None otherwise """ if assignment is None: # if it's the init call, we run AC-3 and we initialize an assignment AC3(csp) assignment = Assignment() if solutions is None: if count: solutions = 0 else: solutions = [] unassigned = [ var for var in list(csp.getVariables() - assignment.getAssignment().keys()) ] var = unassigned[0] values = list(var.getActualDomain() - assignment.getInferencesForVar(var)) for value in values: localAssignment = copy( assignment) # we try to assign a var in a local copy of assignment localAssignment.addVarAssigned(var, value) if csp.assignmentConsistency(localAssignment): if len(localAssignment.getAssignment()) == csp.countVariables( ): # if the assignment is complete and consistent, we can store it if count: solutions += 1 else: solutions.append(localAssignment) else: if count: solutions = allSolutions(csp, count=count, assignment=localAssignment, solutions=solutions) else: allSolutions(csp, count=count, assignment=localAssignment, solutions=solutions) return solutions
def treeSolver(csp: CSP) -> Assignment: """ Finds a possible assignment for tree-like csp Execution time: O(nd^2) d=max cardinality :param csp: csp of interest :return: an assignment, eventually null if the problem is unsatisfiable """ def DAC(csp_i: CSP, sequence_i: List[Variable]) -> bool: """ Directional Arc Consistency. Does inference over the domain, from the leaf to the root of the graph Execution time: O(nd^2) d=max cardinality :param csp_i: csp of interest :param sequence_i: topological order :return False if the csp is unsatisfiable, True otherwise """ for i in range(len(sequence_i) - 1, -1, -1): for j in range(i - 1, -1, -1): constraint = csp_i.findBinaryCostraint(sequence_i[j], sequence_i[i]) if constraint is not None: revise(sequence_i[j], constraint, sequence_i[i]) if sequence_i[i].getActualDomainSize() == 0: return False return True assignment = Assignment() root = csp.getVariables().pop() sequence = topSort(csp, root) if not DAC(csp, sequence): # is unsatisfiable nullAssignment = Assignment() nullAssignment.setNull() return nullAssignment for var in sequence: # for each var in order... for value in var.getActualDomain(): assignment.addVarAssigned( var, value) # ... we try to assign a variable... if csp.assignmentConsistencyForVar( assignment, var): # ... if the partial assignment is consistent... break # ... we go to the next var else: assignment.removeVarAssigned(var) else: # if none of the values is consistent, the csp is unsatisfiable and we return a null assignment nullAssignment = Assignment() nullAssignment.setNull() return nullAssignment return assignment
def orderVariables(csp: CSP, assignment: Assignment) -> Variable: """ Given a csp and an assignment, selects unassigned variable ordered following Minimum Remaining Values and Degree Heuristic :param csp: the csp :param assignment: partial assignment :return: first variable """ varAssignment: Dict[Variable] = assignment.getAssignment() unassigned = [ var for var in list(csp.getVariables() - varAssignment.keys()) ] unassigned.sort(key=lambda var: ( (var.getActualDomainSize() - len(assignment.getInferencesForVar(var)) ), -len(csp.getBinaryConstraintsForVar(var)))) return unassigned[0]
def make_data_temporal(sub): cnt = scipy.io.loadmat('raw_KIST/twist/raw_cnt_' + sub + '.mat')['cnt'][0][0][4] mrk = scipy.io.loadmat('raw_KIST/twist/raw_mrk_' + sub + '.mat')['mrk'][0][0][0][0] y = scipy.io.loadmat('raw_KIST/twist/raw_mrk_' + sub + '.mat')['mrk'][0][0][3] epo = [] for i in range(1, 10): cnt_fs = CSP.arr_bandpass_filter(cnt, i * 4, (i + 1) * 4, 1000, 4) epo.append(cnt_to_epo(cnt_fs, mrk)) y_ = np.transpose(y) kv = BCI.gen_kv_idx(y_, 5) k = 1 for train_idx, test_idx in kv: train_x = epo_temporal_dividing( np.array(epo)[:, train_idx, :, :], 0.6, 0.3) test_x = epo_temporal_dividing( np.array(epo)[:, test_idx, :, :], 0.6, 0.3) train_y = y[:, train_idx] test_y = y[:, test_idx] res = { 'train_x': train_x, 'test_x': test_x, 'train_y': train_y, 'test_y': test_y } scipy.io.savemat('RCNN2/twist_ori_dj/' + sub + '_' + str(k) + '.mat', res) k += 1
def gen_tscsp(sub='1'): path = 'data/A0' + sub + 'T.npz' cnt, mrk, dur, y = Competition.load_cnt_mrk_y(path) epo = [] for i in range(1, 10): # band-pass filtering cnt_fs = CSP.arr_bandpass_filter(cnt, i * 4, (i + 1) * 4, 250, 4) cur_epo = cnt_to_epo(cnt_fs, mrk, dur) cur_epo, y_ = out_label_remover(cur_epo, y) epo.append(cur_epo) y = BCI.lab_inv_translator(y_, 4) kv = BCI.gen_kv_idx(y, 5) k = 1 for train_idx, test_idx in kv: train_x = epo_temporal_dividing( np.array(epo)[:, train_idx, :, :], 4, 0.5, 250) test_x = epo_temporal_dividing( np.array(epo)[:, test_idx, :, :], 4, 0.5, 250) train_y = np.transpose(np.array(y)[train_idx]) test_y = np.transpose(np.array(y)[test_idx]) res = { 'train_x': train_x, 'test_x': test_x, 'train_y': train_y, 'test_y': test_y } scipy.io.savemat( 'competition/ori_4_0.5/' + sub + '_' + str(k) + '.mat', res) k += 1
def data_load(file, filtering=True): path = 'E:/Richard/EEG/Competition/raw/' cnt, mrk, dur, y = com.load_cnt_mrk_y(path + file) if filtering: cnt = csp.arr_bandpass_filter(cnt, 8, 30, 250, 5) epo = com.cnt_to_epo(cnt, mrk, dur) epo, y = com.out_label_remover(epo, y) return epo, y
class NRooks: def __init__(self, N = 1): def rowConstraint(state, values, size = N): pairs = values.items() validStates = list(range(state.state//size*size, state.state//size*size+size)) validPairs = list(filter(lambda pair: pair[1] and pair[0].state in validStates, pairs)) statesToConsider = list(map(lambda x: x[1], validPairs)) return sum(statesToConsider) <= 1 def columnConstraint(state, values, size = N): pairs = values.items() validStates = list(range(state.state % size, size**2,size)) validPairs = list(filter(lambda pair: pair[1] and pair[0].state in validStates, pairs)) statesToConsider = map(lambda x: x[1], validPairs) return sum(statesToConsider) <= 1 self._number = N goal = lambda values, size=N: sum(map(lambda v: v[1], values.items())) == size self._CSP = CSP(goal, ChessState(0, set([True,False]),N)) for i in range(N*N): self._CSP.addVariable(ChessState(i, set([True,False]),N)) self._CSP.addConstraint(rowConstraint) self._CSP.addConstraint(columnConstraint) def solve(self): return self._CSP.solve()
def gen_fbcsp(path='data/A01T.npz'): x, y = Competition.load_one_data(path) for i in range(1, 10): print(i) x_ = CSP.arr_bandpass_filter(x, i * 4, (i + 1) * 4, 250) f = one_fbcsp(x_, y) scipy.io.savemat('mat/fbcsp_ori/A01T_' + str(i) + '_1.mat', f[0]) scipy.io.savemat('mat/fbcsp_ori/A01T_' + str(i) + '_2.mat', f[1]) scipy.io.savemat('mat/fbcsp_ori/A01T_' + str(i) + '_3.mat', f[2])
def __init__(self, N=1): def leftDiagonalConstraint(state, values, size=N): pairs = values.items() validStates = list( range( state.state - min(state.state // size, state.state % size) * (size + 1), size**2, size + 1)) validPairs = list( filter(lambda pair: pair[1] and pair[0].state in validStates, pairs)) statesToConsider = map(lambda x: x[1], validPairs) return sum(statesToConsider) <= 1 def rightDiagonalConstraint(state, values, size=N): pairs = values.items() validStates = list( range( state.state - min(state.state // size, (N - 1) - state.state % size) * (size - 1), size**2, (size - 1))) validPairs = list( filter(lambda pair: pair[1] and pair[0].state in validStates, pairs)) statesToConsider = map(lambda x: x[1], validPairs) return sum(statesToConsider) <= 1 self._number = N goal = lambda values, size=N: sum(map(lambda v: v[1], values.items()) ) == size self._CSP = CSP(goal, ChessState(0, set([True, False]), N)) for i in range(N * N): self._CSP.addVariable(ChessState(i, set([True, False]), N)) self._CSP.addConstraint(leftDiagonalConstraint) self._CSP.addConstraint(rightDiagonalConstraint)
def gen_cnt_data(): import os os.chdir('E:/Richard/Competition/') for i in range(1, 10): path = 'raw/A0' + str(i) + 'T.npz' cnt, mrk, dur, y = Competition.load_cnt_mrk_y(path) f_cnt = CSP.arr_bandpass_filter(cnt, 8, 30, 250, 5) epo = cnt_to_epo(f_cnt, mrk, dur) epo, y_ = out_label_remover(epo, y) new_epo = [] for v in epo: new_epo.append(v[750:1500, :]) new_epo = np.array(new_epo) data = {'x': new_epo, 'y': y_} scipy.io.savemat('epo_f/A0' + str(i), data)
def load_kist_data(sub = '3'): import pickle print(sub) x = scipy.io.loadmat('kist_data/grasp/x_' + sub + '.mat')['x_' + sub].transpose() y = scipy.io.loadmat('kist_data/grasp/y_' + sub + '.mat')['y_' + sub].transpose().argmax(axis=1) y_ = np.array(BCI.lab_inv_translator(y)) kv = BCI.gen_kv_idx(y_, 5) k = 1 for train_idx, test_idx in kv: x_train, y_train = x[train_idx], y_[train_idx] x_test, y_test = x[test_idx], y_[test_idx] file = open('kist_data/grasp/np/' + sub + '_' + str(k) + '.pic', 'wb') pickle.dump({'x_train': x_train, 'y_train': y_train, 'x_test': x_test, 'y_test': y_test}, file) file.close() step = int(len(x[0][0]) / 5) for i in range(0, 5): cur_x_train = x_train[:, :, step * i: step * (i + 1)] cur_x_test = x_test[:, :, step * i: step * (i + 1)] for j in range(1, 10): cur_cur_x_train = CSP.arr_bandpass_filter(cur_x_train, j*4, (j+1)*4, 250) cur_cur_x_test = CSP.arr_bandpass_filter(cur_x_test, j*4, (j+1)*4, 250) f_train = one_fbcsp_for_kist(cur_cur_x_train, y_train.argmax(axis=1)) f_test = one_fbcsp_for_kist(cur_cur_x_test, y_test.argmax(axis=1)) scipy.io.savemat('mat/kist_ori/grasp/A0' + sub + 'T_' + str(i) + '_' + str(j) + '_1_' + str(k) + '_train.mat', f_train[0]) scipy.io.savemat('mat/kist_ori/grasp/A0' + sub + 'T_' + str(i) + '_' + str(j) + '_2_' + str(k) + '_train.mat', f_train[1]) scipy.io.savemat('mat/kist_ori/grasp/A0' + sub + 'T_' + str(i) + '_' + str(j) + '_3_' + str(k) + '_train.mat', f_train[2]) scipy.io.savemat('mat/kist_ori/grasp/A0' + sub + 'T_' + str(i) + '_' + str(j) + '_1_' + str(k) + '_test.mat', f_test[0]) scipy.io.savemat('mat/kist_ori/grasp/A0' + sub + 'T_' + str(i) + '_' + str(j) + '_2_' + str(k) + '_test.mat', f_test[1]) scipy.io.savemat('mat/kist_ori/grasp/A0' + sub + 'T_' + str(i) + '_' + str(j) + '_3_' + str(k) + '_test.mat', f_test[2]) k += 1
def toCSP(self) -> CSP: """ Transforms the map into a CSP :return: the CSP """ csp = CSP() for p in self._region: v = Variable( 'region ' + str('%.3f' % p.x()) + '-' + str('%.3f' % p.y()), self._color) csp.addVariable(v) for l in self._borders: csp.addBinaryConstraint( csp.getVariable('region ' + str('%.3f' % l[0].x()) + '-' + str('%.3f' % l[0].y())), Constraint(different), csp.getVariable('region ' + str('%.3f' % l[1].x()) + '-' + str('%.3f' % l[1].y()))) return csp
def DAC(csp_i: CSP, sequence_i: List[Variable]) -> bool: """ Directional Arc Consistency. Does inference over the domain, from the leaf to the root of the graph Execution time: O(nd^2) d=max cardinality :param csp_i: csp of interest :param sequence_i: topological order :return False if the csp is unsatisfiable, True otherwise """ for i in range(len(sequence_i) - 1, -1, -1): for j in range(i - 1, -1, -1): constraint = csp_i.findBinaryCostraint(sequence_i[j], sequence_i[i]) if constraint is not None: revise(sequence_i[j], constraint, sequence_i[i]) if sequence_i[i].getActualDomainSize() == 0: return False return True
def fb_mibif(x, y): fb_csp = CSP.filterbank_CSP(x) xs = [[], [], [], []] for i in range(len(fb_csp)): xs[y.argmax(axis=1)[i]].append(fb_csp[i]) mis = np.zeros((len(xs), len(xs[0][0]), len(xs[0]) + 10)) for i in range(len(xs)): # class number for j in range(len(xs[i])): # epoch count for k in range(len(xs[i][j])): # filter number one = xs[i][j][k] rest = [] for l in rnage(len(xs)): if i == l: continue try: rest.extend(xs[l][j][k]) except Exception as e: print(e) mis[i][j][k] = mutual_information(one, rest) return np.sum(np.sum(mis, axis=2), axis=0)
def playcsp(listofPos, matrix, count): # print count # do the csp first mine, nomine = CSP.csp(matrix) # print mine # print nomine # print listofPos # print "-----------------------" #judge four cases # case 1: no nomine and no mine, then do dfs if (len(nomine) == 0 and len(mine) == 0): return listofPos[count],listofPos,matrix # case 2: no nomine and have mine, then delete mine from dfs path, run dfs elif(len(nomine)== 0 and len(mine) != 0): for bomb in mine: if bomb in listofPos: listofPos.remove(bomb) matrix[bomb[0]][bomb[1]] = 9 # for cell in matrix: # print cell # print listofPos return listofPos[count],listofPos,matrix # case 3: have nomine and no mine, then click the nomine first elif(len(nomine) != 0 and len(mine) == 0): counting = count for safe in nomine: listofPos.insert(counting, safe) counting += 1 return nomine[0], listofPos,matrix # case 4: have nomine and have mine, then click the nomine first else: for bomb in mine: if bomb in listofPos: listofPos.remove(bomb) matrix[bomb[0]][bomb[1]] = 9 # print listofPos counting = count for safe in nomine: listofPos.insert(counting, safe) counting += 1 return nomine[0], listofPos,matrix
def AC3(csp: CSP) -> bool: """ Reduce CSP's variable's domain by inference, maintaining arc consistency Execution time: O(nd^3) d=max cardinality :param csp: CSP :return: False if the CSP is unsatisfiable """ def unaryRevise(var_i: Variable, constraint_i: Constraint, value_i: Any) -> None: """ Check for every value of the variable if it is compatible with a unary constraint involving this variable; if it doesn't, the value will be hidden :param var_i: variable :param constraint_i: constraint :param value_i: value :return: None """ for valueX in var_i.getActualDomain(): if not constraint_i(valueX, value_i): var_i.hideValue(valueX) # Inference over the unary constraint for var in csp.getUnaryConstraints(): for value in csp.getUnaryConstraintsForVar(var): unaryRevise(var, csp.findUnaryConstraint(var, value), value) # Inference over the binary constraints s = csp.getEdges() while len(s) is not 0: edge = s.pop() # Take an edge... constraint = csp.findBinaryCostraint(edge[0], edge[1]) varI = edge[0] varJ = edge[1] if revise( varI, constraint, varJ ): # ... and analise the relative constraint. If has been made inference, we have to check something if varI.getActualDomainSize( ) == 0: # If a domain is empty, the csp is unsatisfiable return False otherConstraints = csp.getBinaryConstraintsForVar( varI ) # get others constraints involving inferenced variable... otherEdges = set() for var in otherConstraints: if var != varJ: otherEdges.add( (var, varI)) # ... convert them to edges ... s = s.union( otherEdges) # ... and add them to the set of edges to analise return True
def performBacktrackSearch(self, rootNode, node): """ This creates the search tree """ print ("-- proc --", node.state.assignment) #check if we have reached goal state if node.state.checkGoalState(): print ("reached goal state") return True else: #check if there is a case of early failure #if node.state.forwardCheck(): if node.state.arcConsistency(): #find an unassigned variable variable = node.state.selectUnassignedVariable() #for all values in the domain for value in node.state.orderDomainValues(): #check if constraints are satisfied if CSP.checkConstraints(node.state.assignment, variable, value): #create child node childNode = Node(State(node.state.assignment, node.state.possibleValues, variable, value)) node.addChild(childNode) #show the search tree explored so far treeplot = TreePlot() treeplot.generateDiagram(rootNode, childNode) result = self.performBacktrackSearch(rootNode, childNode) if result == True: return True return False
def _topSort(csp_i: CSP, root_i: Variable, previous: List[Variable]) -> List[Variable]: """ Adds to the list the subroot and iterates :param csp_i: csp of interest :param root_i: variable from which it starts :param previous: already elaborated nodes :return: updated list """ children = [] for couple in csp_i.getNeighbour( root_i): # check for every edges involving root if couple[0] == root_i: # discards dual edges if couple[ 1] not in previous: # if the other node is not in list, it is a child children.append(couple[1]) previous.append(root_i) # adding the root to list... for var in children: _topSort(csp_i, var, previous) # ... before to iterate for children return previous
def main(): """ task: 0 - N queens 1 - Latin square size: algorithm: 0 - forward checking 1 - backtracking """ size = int(input("Specify the desired size of the board: ")) csp = CSP.CSP(task=1, size=size) results = csp.start(algorithm=1) # for r in results: # print(r) print("Solutions found: ", len(results[0]), "Number of iterations: ", results[1])
def new_sudoku(file=None): if not file: # Create empty sudoku with domains 1-9 for every cell X = [0] * DIM*DIM D = [ list(range(1,DIM+1)) for _ in range(len(X)) ] else: # Read a sudoku and fill in domain values X = read_sudoku(file) D = [] for i in range(len(X)): if X[i] == 0: D.append( list(range(1,DIM+1)) ) else: D.append( [ X[i] ] ) # Only one constraint to satisfy (on a variety of arcs) C = [ alldiff ] # Seems like it could be done more correctly # Generate all rows, columns, and boxes box_size = int(sqrt(DIM)) rows, cols, boxes = [], [], [] for i in range(0,DIM): row, col, box = [], [], [] for j in range(0,DIM): row.append(i + DIM*j) col.append(DIM*i + j) box.append( (j%box_size) + DIM*(j//box_size) + box_size*(i%box_size) + DIM*box_size*(i//box_size) ) rows.append(tuple(row)) cols.append(tuple(col)) boxes.append(tuple(box)) # Convert all groups into binary arcs groups = rows + cols + boxes arcs = [] for group in groups: arcs += binary_arcs(group) # Return a CSP representation of the sudoku return CSP.CSP(X, D, C, arcs)
def topSort(csp: CSP, root: Variable) -> List[Variable]: """ Given a csp, it searches for a "topological sort" (running a DFS). It needs a variable from which starting, because induced graph isn't a direct graph, so the real topological sort isn't defined :param csp: csp of interest :param root: variable from which it starts :return: Order list of csp's variables :raise Exception: if the graph induced isn't a tree (it is cyclic or not connected) """ def _topSort(csp_i: CSP, root_i: Variable, previous: List[Variable]) -> List[Variable]: """ Adds to the list the subroot and iterates :param csp_i: csp of interest :param root_i: variable from which it starts :param previous: already elaborated nodes :return: updated list """ children = [] for couple in csp_i.getNeighbour( root_i): # check for every edges involving root if couple[0] == root_i: # discards dual edges if couple[ 1] not in previous: # if the other node is not in list, it is a child children.append(couple[1]) previous.append(root_i) # adding the root to list... for var in children: _topSort(csp_i, var, previous) # ... before to iterate for children return previous sequence = _topSort(csp, root, []) if len(sequence) == len(csp.getVariables()) and len(sequence) == len( set(sequence)): return sequence else: raise Exception # It isn't a tree: EVERY var has to be ONE AND ONLY ONE time in the sequence
def gen_tscsp_trick(sub): path = 'data/A0' + sub + 'T.npz' cnt, mrk, dur, y = Competition.load_cnt_mrk_y(path) epo = [] for i in range(1, 10): # band-pass filtering cnt_fs = CSP.arr_bandpass_filter(cnt, i * 4, (i + 1) * 4, 250, 4) cur_epo = cnt_to_epo(cnt_fs, mrk, dur) cur_epo, y_ = out_label_remover(cur_epo, y) epo.append(cur_epo) y = BCI.lab_inv_translator(y_, 4) kv = BCI.gen_kv_idx(y, 5) k = 1 for train_idx, test_idx in kv: train_x = epo_temporal_dividing( np.array(epo)[:, train_idx, :, :], 3.5, 0.5, 250) test_x = epo_temporal_dividing( np.array(epo)[:, test_idx, :, :], 3.5, 0.5, 250) cls = trick_ori(train_x, test_x, np.array(y)[train_idx].argmax(axis=1), np.array(y)[test_idx].argmax(axis=1)) scipy.io.savemat( 'competition/trick/ori_3.5_0.5/' + sub + '_' + str(k) + '.mat', {'cls': cls}) k += 1
def performBacktrackSearch(self, rootNode, node): """ This creates the search tree """ #print "-- proc --", node.state.assignment #check if we have reached our goal state if node.state.checkGoalState(): print "reached goal state" return True else: #find an unassigned variable variable = node.state.selectUnassignedVariable() #for all values in the domain for value in node.state.orderDomainValues(variable): #check if constraints are satisfied if CSP.checkConstraints(node.state.assignment, variable, value): #create child node childNode = Node( State(node.state.assignment, variable, value)) node.addChild(childNode) #show the search tree explorer so far treeplot = TreePlot() treeplot.generateDiagram(rootNode, childNode) result = self.performBacktrackSearch(rootNode, childNode) if result == True: return True return False
def frequentSubG(graph,graphLabel,thr,size): fEdges=countFrequentEdges(graph,graphLabel,thr) #take only the frequent edges from the input graph candidateSet=GraphPmod.subExtSimple(sorted(list(fEdges.keys()))) #generation of size 2 (size is the number of edges) candidateSetApp=copy.deepcopy(candidateSet) domains=GraphPmod.getDomains(graphLabel) solutionSet=[] #list used to avoid the presence of already existing assignments for el in candidateSetApp: if(CSP.isFrequent((el[0],el[1]),graph,domains,solutionSet,el[3])<thr): candidateSet.remove(el) iterations=2 #number of iterations -> at least solutions with size 2 candidateSetPrevious=candidateSet while(len(candidateSet)!=0 and iterations<size): candidateSetPrevious=candidateSet candidateSetNew=GraphPmod.nuovaGenerazione(candidateSet,list(fEdges.keys())) #genration of bigger candidates -> adding all possible frequent edges candidateSetNewApp=copy.deepcopy(candidateSetNew) solutionSet=[] for el in candidateSetNewApp: r=CSP.isFrequent((el[0],el[1]),graph,domains,solutionSet,el[3]) if(r<thr): #counting the occurrences of the candidate subgraph candidateSetNew.remove(el) #if the candidate does not respect the threshold is discarded candidateSet=candidateSetNew if(len(candidateSetNew)!=0): candidateSetPrevious=candidateSetNew iterations+=1 p=0 if(iterations==2): for t in candidateSetPrevious: GraphPmod.printResult(t[0],t[1],p) p+=1 print("Number of total solutions -> ",len(candidateSetPrevious)) print("Number of merged solutions -> ",len(candidateSetPrevious)) print("Number of relations -> ",iterations) else: mergedResult=[] whoIsMerged=set() candidateC=copy.deepcopy(candidateSetPrevious) #comparing all the pairs of frequent subgraph candidateSetPrevious=sorted(candidateSetPrevious, key=lambda k: k[3]) for k in range(len(candidateSetPrevious)): dfs1 = candidateSetPrevious[k][3] flagMerged=0 if(dfs1 not in whoIsMerged): #whoIsMerged.add(k) whoIsMerged.add(dfs1) for i in range(k+1, len(candidateSetPrevious)): dfs2 = candidateSetPrevious[i][3] if (dfs2 not in whoIsMerged): JarJar = DFSmod.jaroSimilarity(dfs1, dfs2) if ((iterations == 3 and JarJar >= 0.9) or (iterations>3 and JarJar >= 0.8)): #if the Jaro Similarity is respected the two result are merged #once one graph is merged into another it is discarded and no more considered #print "MERGED ",dfs1,dfs2,JarJar #print dfs1,dfs2 whoIsMerged.add(dfs2) flagMerged=1 domain2=GraphPmod.getDomains(candidateSetPrevious[i][1]) domain1=GraphPmod.getDomains(candidateSetPrevious[k][1]) toAdd=[] for t in candidateSetPrevious[k][1]: for y in candidateSetPrevious[i][1]: if candidateSetPrevious[k][1][t] == candidateSetPrevious[i][1][y]: adjListI=candidateSetPrevious[i][0][y] for j in adjListI: labelDest=candidateSetPrevious[i][1][j[0]] newLabelDest=None if(labelDest in domain1): newLabelDest=domain1[labelDest][0] else: newLabelDest="v"+str(len(candidateSetPrevious[k][1])) toAdd.append((newLabelDest,labelDest)) candidateSetPrevious[k][0][newLabelDest]=[] newEdges=(newLabelDest,j[1]) if(newEdges not in candidateSetPrevious[k][0][t]): candidateSetPrevious[k][0][t].append(newEdges) #break for toA in toAdd: candidateSetPrevious[k][1][toA[0]]=toA[1] #if(flagMerged==1 or (flagMerged==0 and k not in whoIsMerged)): #if(flagMerged==0): #print "ALONE",dfs1 mergedResult.append(copy.deepcopy(candidateSetPrevious[k])) #mergedResult.append(copy.deepcopy(candidateSetPrevious[k])) #whoIsMerged.add(k) p=0 for el in mergedResult: GraphPmod.printResult(el[0],el[1],p) p+=1 print("Number of merged solutions -> ",len(mergedResult)) print("Number of total solutions -> ",len(candidateSetPrevious)) print("Number of relations -> ",iterations)
board = sudokuGenerator.main() ## printing the unsolved board ## print('Generating sudoku...') sudokuGenerator.displayBoard(board) print('done.') ## Converting to sudokuSolver format ## for i in range(9): for j in range(9): if board[i][j] == 0: board[i][j] = None ## Making graph from list of list print('Generating graph for sudoku board...') G = makeSudokuGraph(board) print('done.') ## Calling the filter function to solve board ## import CSP print('solving board...') startTime = time.clock() assgn = CSP.BacktrackSearch(G) endTime = time.clock() print('done.') for i, j in assgn: board[i][j] = assgn[(i,j)] sudokuGenerator.displayBoard(board) print('Time taken to solve board:',endTime - startTime)
def __init__(self, filename,domain): self.csp1 = CSP.CSP(filename, domain) self.csp1.parseFile() self.finalassignment = {} self.cnt = 0
def main(): gevent.spawn(headset.setup) gevent.sleep(1) try: sample_counter = 0 populate_csv_header() # Find mean #find_mean() # For building a finite time domain En to feed into CSP. En = { 'F3': [], 'FC5': [], 'AF3': [], 'F7': [], 'T7': [], 'P7': [], 'O1': [], 'O2': [], 'P8': [], 'T8': [], 'F8': [], 'AF4': [], 'FC6': [], 'F4': [] } print "Start!" # Run for 5 seconds loop_counter = 0 while loop_counter < 20: # Retrieve emotiv packet packet = headset.dequeue() # Get sensor data F3 = packet.sensors['F3']['value'] FC5 = packet.sensors['FC5']['value'] AF3 = packet.sensors['AF3']['value'] F7 = packet.sensors['F7']['value'] T7 = packet.sensors['T7']['value'] P7 = packet.sensors['P7']['value'] O1 = packet.sensors['O1']['value'] O2 = packet.sensors['O2']['value'] P8 = packet.sensors['P8']['value'] T8 = packet.sensors['T8']['value'] F8 = packet.sensors['F8']['value'] AF4 = packet.sensors['AF4']['value'] FC6 = packet.sensors['FC6']['value'] F4 = packet.sensors['F4']['value'] # Build buffers for FFT F3Buffer.append(F3) FC5Buffer.append(FC5) AF3Buffer.append(AF3) F7Buffer.append(F7) T7Buffer.append(T7) P7Buffer.append(P7) O1Buffer.append(O1) O2Buffer.append(O2) P8Buffer.append(P8) T8Buffer.append(T8) F8Buffer.append(F8) AF4Buffer.append(AF4) FC6Buffer.append(FC6) F4Buffer.append(F4) sample_counter = sample_counter + 1 # Do FFT for each sensor after collecting 64 samples if sample_counter > 32: # Remove high frequency noise and dc offset F3Buffer_clean = sp.preprocess(F3Buffer, 8885.0) FC5Buffer_clean = sp.preprocess(FC5Buffer, 8885.0) AF3Buffer_clean = sp.preprocess(AF3Buffer, 8885.0) F7Buffer_clean = sp.preprocess(F7Buffer, 8885.0) T7Buffer_clean = sp.preprocess(T7Buffer, 8885.0) P7Buffer_clean = sp.preprocess(P7Buffer, 8885.0) O1Buffer_clean = sp.preprocess(O1Buffer, 8885.0) O2Buffer_clean = sp.preprocess(O2Buffer, 8885.0) P8Buffer_clean = sp.preprocess(P8Buffer, 8885.0) T8Buffer_clean = sp.preprocess(T8Buffer, 8885.0) F8Buffer_clean = sp.preprocess(F8Buffer, 8885.0) AF4Buffer_clean = sp.preprocess(AF4Buffer, 8885.0) FC6Buffer_clean = sp.preprocess(FC6Buffer, 8885.0) F4Buffer_clean = sp.preprocess(F4Buffer, 8885.0) # Put clean data into En for i in range(0, len(F3Buffer_clean)): En['F3'].append(F3Buffer_clean[i]) En['FC5'].append(FC5Buffer_clean[i]) En['AF3'].append(AF3Buffer_clean[i]) En['F7'].append(F7Buffer_clean[i]) En['T7'].append(T7Buffer_clean[i]) En['P7'].append(P7Buffer_clean[i]) En['O1'].append(O1Buffer_clean[i]) En['O2'].append(O2Buffer_clean[i]) En['P8'].append(P8Buffer_clean[i]) En['T8'].append(T8Buffer_clean[i]) En['F8'].append(F8Buffer_clean[i]) En['AF4'].append(AF4Buffer_clean[i]) En['FC6'].append(FC6Buffer_clean[i]) En['F4'].append(F4Buffer_clean[i]) # Apply DFT to extract frequency components f3_fft = fft.compute_fft(F3Buffer_clean) fc5_fft = fft.compute_fft(FC5Buffer_clean) af3_fft = fft.compute_fft(AF3Buffer_clean) f7_fft = fft.compute_fft(F7Buffer_clean) t7_fft = fft.compute_fft(T7Buffer_clean) p7_fft = fft.compute_fft(P7Buffer_clean) o1_fft = fft.compute_fft(O1Buffer_clean) o2_fft = fft.compute_fft(O2Buffer_clean) p8_fft = fft.compute_fft(P8Buffer_clean) t8_fft = fft.compute_fft(T8Buffer_clean) f8_fft = fft.compute_fft(F8Buffer_clean) af4_fft = fft.compute_fft(AF4Buffer_clean) fc6_fft = fft.compute_fft(FC6Buffer_clean) f4_fft = fft.compute_fft(F4Buffer_clean) # Build dictionary fft_dict = { 'F3': f3_fft, 'FC5': fc5_fft, 'AF3': af3_fft, 'F7': f7_fft, 'T7': t7_fft, 'P7': p7_fft, 'O1': o1_fft, 'O2': o2_fft, 'P8': p8_fft, 'T8': t8_fft, 'F8': f8_fft, 'AF4': af4_fft, 'FC6': fc6_fft, 'F4': f4_fft } # Write data set to a csv file fft.write_to_file(fft_dict, start_time) # Clear buffers clear_buffers() sample_counter = 0 loop_counter = loop_counter + 1 gevent.sleep(0) # Feed into CSP filter. csp.create_e_matrix(En) except KeyboardInterrupt: headset.close() finally: headset.close()
def readCsp(textFile): csp = CSP() board = [] file = open(textFile) firstLine = file.readline().split(" ") global numberOfRows numberOfRows = int(firstLine[1]) global numberOfColumns numberOfColumns = int(firstLine[0]) domainX = range(numberOfRows) domainY = range(numberOfColumns) # Creates board for i in range(numberOfRows): board.append([]) for j in range(numberOfColumns): board[i].append(Node(i, j)) # Add start position for segments in rows counter = 0 for i in range(numberOfRows): line = file.readline().split(" ") for j in line: block = Block(counter, int(j), i, -1) counter += 1 csp.variables.append(block) csp.constraints[block] = [] csp.domains[block] = deepcopy(domainX) # Add start position for segments in columns for i in range(numberOfColumns): line = file.readline().split(" ") line.reverse() for j in line: block = Block(counter, int(j), -1, i) counter += 1 csp.variables.append(block) csp.constraints[block] = [] csp.domains[block] = deepcopy(domainY) # Add constraints to CSP for j in csp.variables: # Check if segment is the last if j.index == len(csp.variables) - 1: csp.constraints[j].append(Constraint([j], j.text + " + " + str(j.length) + " <= " + str(numberOfColumns))) # Segment is in a row elif j.colNumber == -1: if j.rowNumber == csp.variables[j.index + 1].rowNumber: # j.text = 'b1' # str(j.length) = '2' # csp.variables[j.index + 1].text = 'b2' #'b1 + 2 < b2' csp.constraints[j].append( Constraint( [j, csp.variables[j.index + 1]], j.text + " + " + str(j.length) + " < " + csp.variables[j.index + 1].text, ) ) csp.constraints[csp.variables[j.index + 1]].append( Constraint( [csp.variables[j.index + 1], j], j.text + " + " + str(j.length) + " < " + csp.variables[j.index + 1].text, ) ) else: csp.constraints[j].append( Constraint([j], j.text + " + " + str(j.length) + " <= " + str(numberOfColumns)) ) # Segment is in a column else: if j.colNumber == csp.variables[j.index + 1].colNumber: csp.constraints[j].append( Constraint( [j, csp.variables[j.index + 1]], j.text + " + " + str(j.length) + " < " + csp.variables[j.index + 1].text, ) ) csp.constraints[csp.variables[j.index + 1]].append( Constraint( [csp.variables[j.index + 1], j], j.text + " + " + str(j.length) + " < " + csp.variables[j.index + 1].text, ) ) else: csp.constraints[j].append(Constraint([j], j.text + " + " + str(j.length) + " <= " + str(numberOfRows))) return csp