def look_n_predict(presumptive=False): ret = '' bots_in_sight = False mock_bombs = bombs[:] _line_of_sight = line_of_sight(self.me.loc, board) for bot in (bot for bot in alive_players if bot.id != game.PLAYER_ID): if bot.loc in _line_of_sight: bots_in_sight = True log("Bot %s in line of sight @ %s"%(bot.id,bot.loc)) # assume bot will place bomb bomb_count = len([bomb for bomb in bombs if (bomb.player_id == bot.id and bomb.tick > 1)]) for _ in range(5-bomb_count): b = game.Bomb(bot.id, bot.loc.x, bot.loc.y, DEFAULT_TICKS) b.ghost = True mock_bombs.append(b) if bots_in_sight: _backup = get_current_round() mock_state = (board, alive_players, mock_bombs, previous_actions) game.CURRENT_ROUND = game.Round(mock_state, 1337) best_move = get_best_move(self.me.loc, mock_state) log("** If bots place bombs -> best move: %s"%best_move) ret = best_move game.CURRENT_ROUND = _backup return (bots_in_sight, ret)
def look_n_predict(presumptive=False): ret = '' bots_in_sight = False mock_bombs = bombs[:] _line_of_sight = line_of_sight(self.me.loc, board) for bot in (bot for bot in alive_players if bot.id != game.PLAYER_ID): if bot.loc in _line_of_sight: bots_in_sight = True log("Bot %s in line of sight @ %s" % (bot.id, bot.loc)) # assume bot will place bomb bomb_count = len([ bomb for bomb in bombs if (bomb.player_id == bot.id and bomb.tick > 1) ]) for _ in range(5 - bomb_count): b = game.Bomb(bot.id, bot.loc.x, bot.loc.y, DEFAULT_TICKS) b.ghost = True mock_bombs.append(b) if bots_in_sight: _backup = get_current_round() mock_state = (board, alive_players, mock_bombs, previous_actions) game.CURRENT_ROUND = game.Round(mock_state, 1337) best_move = get_best_move(self.me.loc, mock_state) log("** If bots place bombs -> best move: %s" % best_move) ret = best_move game.CURRENT_ROUND = _backup return (bots_in_sight, ret)
def play_round(self, state): (board, alive_players, bombs, previous_actions) = state self.me = get_me() # current_round = get_current_round() if not self.me.is_alive(): log("Fatal Error: Dead :( ... fatal, haha, get it?") return "break" log("My position: %s"%self.me.loc) # get possible commands possible_commands = get_possible_moves(self.me.loc, board, bombs) log("Possible commands: %s"%possible_commands) ret = '' # Rule 1: defend your ass ret = self.defend(state, possible_commands) # Rule 2: if no need to defend, attack! if not ret: log("Attack mode activated. Prepare to die bitchez.") ret = self.attack(state, possible_commands) elif ret == "pass": log("Tried returning \"pass\". Why not see if we can attack meanwhile?") ret = self.attack(state, possible_commands) return ret if ret else "pass"
def play_round(self, state): (board, alive_players, bombs, previous_actions) = state self.me = get_me() # current_round = get_current_round() if not self.me.is_alive(): log("Fatal Error: Dead :( ... fatal, haha, get it?") return "break" log("My position: %s" % self.me.loc) # get possible commands possible_commands = get_possible_moves(self.me.loc, board, bombs) log("Possible commands: %s" % possible_commands) ret = '' # Rule 1: defend your ass ret = self.defend(state, possible_commands) # Rule 2: if no need to defend, attack! if not ret: log("Attack mode activated. Prepare to die bitchez.") ret = self.attack(state, possible_commands) elif ret == "pass": log("Tried returning \"pass\". Why not see if we can attack meanwhile?" ) ret = self.attack(state, possible_commands) return ret if ret else "pass"
def passive_defence(): # check if trapped if not loc_is_safe(self.me.loc, 1, False, True): log("Threat level low, but I seem trapped!") pc = possible_commands[:] pc.remove("pass") return move(pc, False) # check if other bot in direct line of sight # and predict best move if bot places bomb lnp = look_n_predict() if lnp and lnp[1]: return lnp[1] return
def passive_defence(): # check if trapped if not loc_is_safe(self.me.loc, 1, False, True): log("Threat level low, but I seem trapped!") pc = possible_commands[:] pc.remove("pass") return move(pc, False) # check if other bot in direct line of sight # and predict best move if bot places bomb lnp = look_n_predict() if lnp and lnp[1]: return lnp[1] return
def attack(self, state, possible_commands, force=False): # do no checks, just do it! if force: return BOMB_MIN_TICK (board, alive_players, bombs, previous_actions) = state if not (len(get_bombs_for_player(self.my_id, bombs)) < BOMB_MAX_PER_PLAYER): log("Cannot place more bombs.. :( Fuucking buullshit!") return # Check if other bots around for bot in (bot for bot in alive_players if bot.id != game.PLAYER_ID): l = abs(self.me.loc - bot) d = l.x + l.y if d > ATTACK_DISTANCE: log("Other bots too far away to be wasting bombs..") try: prev_action = get_prev_action_for_player( self.my_id, previous_actions).action possible_commands.remove( (DIRECTIONS[-(RDIRECTIONS[prev_action])])) except: pass ret = possible_commands.pop() if ret == "pass": ret = possible_commands.pop() return ret # Now place bomb, but first check if not kamikaze move mock_bombs = bombs[:] mock_state = (board, alive_players, mock_bombs, previous_actions) # pushing clock 1 tick ahead for bomb in mock_bombs: bomb.tick -= 1 _backup = get_current_round() for bomb_tick in range(BOMB_MIN_TICK + 5, BOMB_MAX_TICK + 1, 10): mock_bombs.append( game.Bomb(self.my_id, self.me.loc.x, self.me.loc.y, bomb_tick)) game.CURRENT_ROUND = game.Round(mock_state, 1337) best_move = get_best_move(self.me.loc, mock_state) log("** If I'd place a bomb -> best move: %s" % best_move) if best_move: log("Placing bomb with %s ticks" % bomb_tick) return bomb_tick game.CURRENT_ROUND = _backup log("Can't place bomb without killing myself.") return
def attack(self, state, possible_commands, force=False): # do no checks, just do it! if force: return BOMB_MIN_TICK (board, alive_players, bombs, previous_actions) = state if not (len(get_bombs_for_player(self.my_id, bombs)) < BOMB_MAX_PER_PLAYER): log("Cannot place more bombs.. :( Fuucking buullshit!") return # Check if other bots around for bot in (bot for bot in alive_players if bot.id != game.PLAYER_ID): l = abs(self.me.loc - bot) d = l.x + l.y if d > ATTACK_DISTANCE: log("Other bots too far away to be wasting bombs..") try: prev_action = get_prev_action_for_player(self.my_id, previous_actions).action possible_commands.remove((DIRECTIONS[-(RDIRECTIONS[prev_action])])) except: pass ret = possible_commands.pop() if ret == "pass": ret = possible_commands.pop() return ret # Now place bomb, but first check if not kamikaze move mock_bombs = bombs[:] mock_state = (board, alive_players, mock_bombs, previous_actions) # pushing clock 1 tick ahead for bomb in mock_bombs: bomb.tick -= 1 _backup = get_current_round() for bomb_tick in range(BOMB_MIN_TICK+5, BOMB_MAX_TICK+1, 10): mock_bombs.append(game.Bomb(self.my_id, self.me.loc.x, self.me.loc.y, bomb_tick)) game.CURRENT_ROUND = game.Round(mock_state, 1337) best_move = get_best_move(self.me.loc, mock_state) log("** If I'd place a bomb -> best move: %s"%best_move) if best_move: log("Placing bomb with %s ticks"%bomb_tick) return bomb_tick game.CURRENT_ROUND = _backup log("Can't place bomb without killing myself.") return
def get_best_move(loc, state, ticks=DEFAULT_TICKS, allow_pass=True): # reset shortest global shortest for b00l in [True, False]: shortest = RECURSION_LIMIT safelist = get_safe_move(loc, state, ticks=ticks, traps=b00l, allow_pass=allow_pass) if safelist: break if not safelist: return None best_moves = safelist[0] for moves in safelist[1:]: if len(moves) < len(best_moves): best_moves = moves log("Best move strategy (%s ticks): %s"%(ticks,best_moves)) if not b00l: log("It's a trap! ... but what else am I gonna do") # safelist is mutable, clear it! del safelist[:] return best_moves[0] if best_moves else None
def move(possible_commands=possible_commands, allow_pass=True): for move in possible_commands: if loc_is_safe(self.me.loc + RDIRECTIONS[move], traps=False): return move # if no single move guarantees safety, look for closest safe spot best_move = get_best_move(self.me.loc, state, allow_pass=allow_pass) log("Calculated best move (%s ticks): %s"%(DEFAULT_TICKS, best_move)) if best_move: return best_move # check for closest safe spot but for less turns ahead for i in reversed(range(1,6)): best_move = get_best_move(self.me.loc, state, i) log("Calculated best move (%s ticks): %s"%(i, best_move)) if best_move: return best_move # else PANIC! Haha, jk. No but seriously, auto-destruct. log("No safe moves! Self-destruct sequence initiated...") return self.attack(0, 0, force=True)
def wrapper(*args, **kwargs): ret = func(*args, **kwargs) me = get_me() state = args[1] bombs = state[2] if me.is_alive(): if not check(ret, me, bombs): log("Wanted to return \""+str(ret)+"\" - blocked by I.S.A.S.") io.PREFIX = "* " # try to find best move for 3,2,1 turns ahead for i in reversed(range(1,4)): best_move = get_best_move(me.loc, args[1], ticks=i) # bombs = args[1][2] # log("Bombs ISAS %s"%bombs) # for bomb in bombs: # log("Ticks %s"%bomb.tick) if check(best_move, me, bombs): log("Alternative best move (%s ticks): %s"%(i, best_move)) io.PREFIX = "" return best_move log("No other option - prepare to die...") io.PREFIX = "" return ret
def move(possible_commands=possible_commands, allow_pass=True): for move in possible_commands: if loc_is_safe(self.me.loc + RDIRECTIONS[move], traps=False): return move # if no single move guarantees safety, look for closest safe spot best_move = get_best_move(self.me.loc, state, allow_pass=allow_pass) log("Calculated best move (%s ticks): %s" % (DEFAULT_TICKS, best_move)) if best_move: return best_move # check for closest safe spot but for less turns ahead for i in reversed(range(1, 6)): best_move = get_best_move(self.me.loc, state, i) log("Calculated best move (%s ticks): %s" % (i, best_move)) if best_move: return best_move # else PANIC! Haha, jk. No but seriously, auto-destruct. log("No safe moves! Self-destruct sequence initiated...") return self.attack(0, 0, force=True)
def defend(self, state, possible_commands): (board, alive_players, bombs, previous_actions) = state bots_in_sight = False def look_n_predict(presumptive=False): ret = '' bots_in_sight = False mock_bombs = bombs[:] _line_of_sight = line_of_sight(self.me.loc, board) for bot in (bot for bot in alive_players if bot.id != game.PLAYER_ID): if bot.loc in _line_of_sight: bots_in_sight = True log("Bot %s in line of sight @ %s"%(bot.id,bot.loc)) # assume bot will place bomb bomb_count = len([bomb for bomb in bombs if (bomb.player_id == bot.id and bomb.tick > 1)]) for _ in range(5-bomb_count): b = game.Bomb(bot.id, bot.loc.x, bot.loc.y, DEFAULT_TICKS) b.ghost = True mock_bombs.append(b) if bots_in_sight: _backup = get_current_round() mock_state = (board, alive_players, mock_bombs, previous_actions) game.CURRENT_ROUND = game.Round(mock_state, 1337) best_move = get_best_move(self.me.loc, mock_state) log("** If bots place bombs -> best move: %s"%best_move) ret = best_move game.CURRENT_ROUND = _backup return (bots_in_sight, ret) def move(possible_commands=possible_commands, allow_pass=True): for move in possible_commands: if loc_is_safe(self.me.loc + RDIRECTIONS[move], traps=False): return move # if no single move guarantees safety, look for closest safe spot best_move = get_best_move(self.me.loc, state, allow_pass=allow_pass) log("Calculated best move (%s ticks): %s"%(DEFAULT_TICKS, best_move)) if best_move: return best_move # check for closest safe spot but for less turns ahead for i in reversed(range(1,6)): best_move = get_best_move(self.me.loc, state, i) log("Calculated best move (%s ticks): %s"%(i, best_move)) if best_move: return best_move # else PANIC! Haha, jk. No but seriously, auto-destruct. log("No safe moves! Self-destruct sequence initiated...") return self.attack(0, 0, force=True) def passive_defence(): # check if trapped if not loc_is_safe(self.me.loc, 1, False, True): log("Threat level low, but I seem trapped!") pc = possible_commands[:] pc.remove("pass") return move(pc, False) # check if other bot in direct line of sight # and predict best move if bot places bomb lnp = look_n_predict() if lnp and lnp[1]: return lnp[1] return if not bombs: log("No bombs. No stress.") return passive_defence() bombs.sort(key=lambda bomb: bomb.x) log("Bombs at %s"%bombs) # log("Blast paths for next turn %s"%current_round.get_blast_paths(1)) if loc_is_safe(self.me.loc): log("Not in blast path, chillax.") return passive_defence() # else (is in blastpath) move log("In blast path, run Forrest!") return move() return "pass"
def defend(self, state, possible_commands): (board, alive_players, bombs, previous_actions) = state bots_in_sight = False def look_n_predict(presumptive=False): ret = '' bots_in_sight = False mock_bombs = bombs[:] _line_of_sight = line_of_sight(self.me.loc, board) for bot in (bot for bot in alive_players if bot.id != game.PLAYER_ID): if bot.loc in _line_of_sight: bots_in_sight = True log("Bot %s in line of sight @ %s" % (bot.id, bot.loc)) # assume bot will place bomb bomb_count = len([ bomb for bomb in bombs if (bomb.player_id == bot.id and bomb.tick > 1) ]) for _ in range(5 - bomb_count): b = game.Bomb(bot.id, bot.loc.x, bot.loc.y, DEFAULT_TICKS) b.ghost = True mock_bombs.append(b) if bots_in_sight: _backup = get_current_round() mock_state = (board, alive_players, mock_bombs, previous_actions) game.CURRENT_ROUND = game.Round(mock_state, 1337) best_move = get_best_move(self.me.loc, mock_state) log("** If bots place bombs -> best move: %s" % best_move) ret = best_move game.CURRENT_ROUND = _backup return (bots_in_sight, ret) def move(possible_commands=possible_commands, allow_pass=True): for move in possible_commands: if loc_is_safe(self.me.loc + RDIRECTIONS[move], traps=False): return move # if no single move guarantees safety, look for closest safe spot best_move = get_best_move(self.me.loc, state, allow_pass=allow_pass) log("Calculated best move (%s ticks): %s" % (DEFAULT_TICKS, best_move)) if best_move: return best_move # check for closest safe spot but for less turns ahead for i in reversed(range(1, 6)): best_move = get_best_move(self.me.loc, state, i) log("Calculated best move (%s ticks): %s" % (i, best_move)) if best_move: return best_move # else PANIC! Haha, jk. No but seriously, auto-destruct. log("No safe moves! Self-destruct sequence initiated...") return self.attack(0, 0, force=True) def passive_defence(): # check if trapped if not loc_is_safe(self.me.loc, 1, False, True): log("Threat level low, but I seem trapped!") pc = possible_commands[:] pc.remove("pass") return move(pc, False) # check if other bot in direct line of sight # and predict best move if bot places bomb lnp = look_n_predict() if lnp and lnp[1]: return lnp[1] return if not bombs: log("No bombs. No stress.") return passive_defence() bombs.sort(key=lambda bomb: bomb.x) log("Bombs at %s" % bombs) # log("Blast paths for next turn %s"%current_round.get_blast_paths(1)) if loc_is_safe(self.me.loc): log("Not in blast path, chillax.") return passive_defence() # else (is in blastpath) move log("In blast path, run Forrest!") return move() return "pass"
def preprocess(X, GDM, normalise=1000, replicatesIDs=None, flipSamples=None, expressionValueThreshold=10.0, replacementVal=0.0, atleastinconditions=1, atleastindatasets=1, absvalue=False, usereplacementval=False, filteringtype='raw', filterflat=True, params=None, datafiles=None): # Fixing parameters Xloc = ds.listofarrays2arrayofarrays(X) L = len(Xloc) if datafiles is None: if L == 1: datafiles = ['X'] else: datafiles = np.array([], dtype=str) for i in range(L): datafiles = np.append(datafiles, 'X{0}'.format(i + 1)) if params is None: params = {} if replicatesIDs is None: replicatesIDsloc = [ np.array([ii for ii in range(x.shape[1])]) for x in Xloc ] else: replicatesIDsloc = ds.listofarrays2arrayofarrays(replicatesIDs) replicatesIDsloc = [np.array(x) for x in replicatesIDsloc] if flipSamples is None: flipSamplesloc = None else: flipSamplesloc = ds.listofarrays2arrayofarrays(flipSamples) flipSamplesloc = [np.array(x) for x in flipSamplesloc] # Revise if the if statement below is accurate! if not isinstance(normalise, (list, tuple, np.ndarray)): normaliseloc = [ normalise if isinstance(normalise, (list, tuple, np.ndarray)) else [normalise] for i in range(L) ] normaliseloc = ds.listofarrays2arrayofarrays(normaliseloc) else: normaliseloc = [ nor if isinstance(nor, (list, tuple, np.ndarray)) else [nor] for nor in normalise ] normaliseloc = ds.listofarrays2arrayofarrays(normaliseloc) # Get rid of nans by fixing Xproc = Xloc for l in range(L): Xproc[l] = fixnans(Xproc[l]) # Prepare applied_norm dictionary before any normalisation takes place applied_norm = collec.OrderedDict(zip(datafiles, deepcopy(normaliseloc))) # Tell the user if any automatic normalisation is taking place allare1000 = True anyis1000 = False for l in range(L): if 1000 in normaliseloc[l]: anyis1000 = True else: allare1000 = False if allare1000: io.log(' - Automatic normalisation mode (default in v1.7.0+).') io.log(' Clust automatically normalises your dataset(s).') io.log(' To switch it off, use the `-n 0` option (not recommended).') io.log(' Check https://github.com/BaselAbujamous/clust for details.') elif anyis1000: io.log( ' - Some datasets are not assigned normalisation codes in the provided' ) io.log( ' normalisation file. Clust automatically identifies and applies the' ) io.log(' most suitable normalisation to them (default in v1.7.0+).') io.log(' If you don' 't want clust to normalise them, assign each of them a') io.log(' normalisation code of 0 in the normalisation file.') io.log(' Check https://github.com/BaselAbujamous/clust for details.') # Quantile normalisation for l in range(L): if 101 in normaliseloc[l] or 1000 in normaliseloc[l]: Xproc[l] = normaliseSampleFeatureMat(Xproc[l], 101)[0] if 101 in normaliseloc[l]: i = np.argwhere(np.array(normaliseloc[l]) == 101) i = i[0][0] normaliseloc[l][i] = 0 # Combine replicates and sort out flipped samples Xproc = combineReplicates(Xproc, replicatesIDsloc, flipSamplesloc) # Filter genes not exceeding the threshold (Xproc, GDMnew, Iincluded) = filterlowgenes(Xproc, GDM, expressionValueThreshold, replacementVal, atleastinconditions, atleastindatasets, absvalue, usereplacementval, filteringtype) # Normalise for l in range(L): (Xproc[l], codes) = normaliseSampleFeatureMat(Xproc[l], normaliseloc[l]) if np.all(codes == normaliseloc[l]): applied_norm[datafiles[l]] = op.arraytostring( applied_norm[datafiles[l]], delim=' ', openbrac='', closebrac='') else: applied_norm[datafiles[l]] = op.arraytostring(codes, delim=' ', openbrac='', closebrac='') if filterflat: io.log( ' - Flat expression profiles filtered out (default in v1.7.0+).') io.log( ' To switch it off, use the --no-fil-flat option (not recommended).' ) io.log(' Check https://github.com/BaselAbujamous/clust for details.') (Xproc, GDMnew, Iincluded) = filterFlat(Xproc, GDMnew, Iincluded) # Prepare params for the output params = dict( params, **{ 'normalise': normaliseloc, 'replicatesIDs': replicatesIDs, 'flipSamples': flipSamplesloc, 'L': L }) return Xproc, GDMnew, Iincluded, params, applied_norm
def uncles(X, type='A', Ks=[n for n in range(2, 21)], params=None, methods=None, methodsDetailed=None, U=None, Utype='PM', relabel_technique='minmin', setsP=None, setsN=None, dofuzzystretch=False, wsets=None, wmethods=None, GDM=None, smallestClusterSize=11, CoPaMfinetrials=1, CoPaMfinaltrials=1, binarise_techniqueP='DTB', binarise_paramP=np.arange(0.0, 1.1, 0.1, dtype='float'), binarise_techniqueN='DTB', binarise_paramN=np.concatenate(([sys.float_info.epsilon], np.arange(0.1, 1.1, 0.1, dtype='float'))), Xnames=None, deterministic=False, ncores=1): Xloc = ds.listofarrays2arrayofarrays(X) L = len(Xloc) # Number of datasets # Fix parameters if params is None: params = {} if setsP is None: setsP = [x for x in range(int(math.floor(L / 2)))] if setsN is None: setsN = [x for x in range(int(math.floor(L / 2)), L)] setsPN = np.array(np.concatenate((setsP, setsN), axis=0), dtype=int) Xloc = Xloc[setsPN] L = np.shape(Xloc)[0] # Number of datasets if wsets is None: wsets = np.array([1 for x in range(L)]) else: wsets = np.array(wsets)[setsPN] if GDM is None: Ng = np.shape(Xloc[0])[0] GDMloc = np.ones([Ng, L], dtype='bool') else: GDMloc = GDM[:, setsPN] Ng = GDMloc.shape[0] if Xnames is None: Xnames = ['X{0}'.format(l) for l in range(L)] if methods is None: largest_DS = np.max([x.shape[0] for x in Xloc]) if (largest_DS <= maxgenesinsetforpdist): if (deterministic): methods = [['k-means'], ['HC']] else: methods = [['k-means'], ['SOMs'], ['HC']] else: if (deterministic): methods = [['k-means']] else: methods = [['k-means'], ['SOMs']] else: largest_DS = np.max([x.shape[0] for x in Xloc]) if (largest_DS > maxgenesinsetforpdist): methods = [ m for m in methods if 'hc' not in [entry.lower() for entry in m] ] if not methods: io.log('No valid base clustering can be used. Please note that clust would not use HC clustering ' \ 'on datasets with more than {0} genes. You have a dataset with {1} genes.' \ ''.format(maxgenesinsetforpdist, largest_DS)) io.log('Clust will terminate here.') io.log(op.bottomline(), addextrastick=False) sys.exit() if methodsDetailed is None: methodsDetailedloc = np.array([methods for l in range(L)]) else: methodsDetailedloc = methodsDetailed[setsPN] if wmethods is None: wmethods = [[1 for x in m] for m in methodsDetailedloc] elif not isinstance(wmethods[0], (list, tuple, np.ndarray)): wmethods = np.tile(methods, [L, 1]) else: wmethods = np.array(wmethods)[setsPN] setsPloc = [ii for ii in range(len(setsP))] if L > len(setsPloc): setsNloc = [ii for ii in range(len(setsPloc), L)] Ds = [nu.closest_to_square_factors(k) for k in Ks] # Grid sizes for the SOMs method for each value of K NKs = len(Ks) # Number of K values # Clustering if U is None: Utype = 'PM' Uloc = np.array([None] * (L * NKs)).reshape([L, NKs]) totalparallel = np.sum(Ks) * np.sum( [len(meths) for meths in methodsDetailedloc]) for meths in methodsDetailedloc: for meth in meths: if 'k-means' in meth: totalparallel += np.max(Ks) * np.max(Ks) continue io.resetparallelprogress(totalparallel) for l in range(L): # Cache kmeans initialisations for the dataset once to save time: cl.cache_kmeans_init(Xloc[l], Ks, methodsDetailedloc[l], datasetID=l) # Now go to parallel clustering with warnings.catch_warnings(): warnings.simplefilter("ignore") Utmp = Parallel(n_jobs=ncores)\ (delayed(clustDataset) (Xloc[l], Ks[ki], Ds[ki], methodsDetailedloc[l], GDMloc[:, l], Ng, l) for ki in range(NKs)) Utmp = [u for u in Utmp] for ki in range(NKs): Uloc[l, ki] = Utmp[ki] gc.collect() #io.updateparallelprogress(np.sum(Ks) * len(methodsDetailedloc)) else: Uloc = ds.listofarrays2arrayofarrays(U)[setsPN] # Calculate a CoPaM for each dataset at each K CoPaMsFine = np.array([None] * (L * NKs)).reshape([L, NKs]) for l in range(L): for ki in range(NKs): if Utype.lower() == 'pm': CoPaMsFineTmp = [ generateCoPaM(Uloc[l, ki], relabel_technique=relabel_technique, X=[Xloc[l]], w=wmethods[l], K=Ks[ki], GDM=GDMloc[:, l].reshape([-1, 1])) for i in range(CoPaMfinetrials) ] elif Utype.lower() == 'idx': CoPaMsFineTmp = \ [generateCoPaMfromidx(Uloc[l, ki], relabel_technique=relabel_technique, X=Xloc, w=wmethods[l], K=Ks[ki]) for i in range(CoPaMfinetrials)] else: raise ValueError('Invalid Utype') CoPaMsFine[l, ki] = generateCoPaM(CoPaMsFineTmp, relabel_technique=relabel_technique, X=[Xloc[l]], GDM=GDMloc[:, l].reshape([-1, 1])) if dofuzzystretch: CoPaMsFine[l, ki] = fuzzystretch(CoPaMsFine[l, ki]) # Calculate the final CoPaM for each K CoPaMs = np.array([None] * (CoPaMfinaltrials * NKs)).reshape( [CoPaMfinaltrials, NKs]) CoPaMsP = np.array([None] * (CoPaMfinaltrials * NKs)).reshape( [CoPaMfinaltrials, NKs]) CoPaMsN = np.array([None] * (CoPaMfinaltrials * NKs)).reshape( [CoPaMfinaltrials, NKs]) for t in range(CoPaMfinaltrials): for ki in range(NKs): if type == 'A': if Utype.lower() == 'pm': CoPaMs[t, ki] = generateCoPaM( CoPaMsFine[:, ki], relabel_technique=relabel_technique, w=wsets, X=Xloc, GDM=GDMloc) elif Utype.lower() == 'idx': CoPaMs[t, ki] = generateCoPaMfromidx( CoPaMsFine[:, ki], relabel_technique=relabel_technique, X=Xloc, w=wsets, GDM=GDMloc) else: raise ValueError('Invalid Utype') elif type == 'B': if Utype.lower() == 'pm': CoPaMsP[t, ki] = generateCoPaM( CoPaMsFine[setsPloc, ki], relabel_technique=relabel_technique, X=Xloc, w=wsets[setsPloc], GDM=GDMloc[:, setsPloc]) CoPaMsN[t, ki] = generateCoPaM( CoPaMsFine[setsNloc, ki], relabel_technique=relabel_technique, X=Xloc, w=wsets[setsNloc], GDM=GDMloc[:, setsNloc]) elif Utype.lower() == 'idx': CoPaMsP[t, ki] = generateCoPaMfromidx( CoPaMsFine[setsPloc, ki], relabel_technique=relabel_technique, X=Xloc, w=wsets[setsPloc], GDM=GDMloc[:, setsPloc]) CoPaMsN[t, ki] = generateCoPaMfromidx( CoPaMsFine[setsNloc, ki], relabel_technique=relabel_technique, X=Xloc, w=wsets[setsNloc], GDM=GDMloc[:, setsNloc]) else: raise ValueError('Invalid Utype') else: raise ValueError( 'Invalid UNCLES type. It has to be either A or B') # Binarise NPp = len(binarise_paramP) # Number of P params NNp = len(binarise_paramN) # Number of N params if type == 'A': B = np.zeros([CoPaMfinaltrials, NPp, 1, NKs], dtype=object) Mc = np.zeros([CoPaMfinaltrials, NKs], dtype=object) elif type == 'B': B = np.zeros([CoPaMfinaltrials, NPp, NNp, NKs], dtype=object) Mc = np.zeros([CoPaMfinaltrials, NKs], dtype=object) for t in range(CoPaMfinaltrials): for ki in range(NKs): if type == 'A': # Pre-sorting binarisation for p in range(NPp): B[t, p, 0, ki] = binarise(CoPaMs[t, ki], binarise_techniqueP, binarise_paramP[p]) Mc[t, ki] = [np.sum(Bp, axis=0) for Bp in B[t, :, 0, ki]] # Sorting CoPaMs[t, ki] = sortclusters(CoPaMs[t, ki], Mc[t, ki], smallestClusterSize) # Post-sorting binarisation for p in range(NPp): B[t, p, 0, ki] = binarise(CoPaMs[t, ki], binarise_techniqueP, binarise_paramP[p]) Mc[t, ki] = [np.sum(Bp, axis=0) for Bp in B[t, :, 0, ki]] elif type == 'B': # Pre-sorting binarisation BP = [ binarise(CoPaMsP[t, ki], binarise_techniqueP, binarise_paramP[p]) for p in range(NPp) ] McP = [np.sum(BPp, axis=0) for BPp in BP] BN = [ binarise(CoPaMsN[t, ki], binarise_techniqueN, binarise_paramN[p]) for p in range(NNp) ] McN = [np.sum(BNp, axis=0) for BNp in BN] # Sorting CoPaMsP[t, ki] = sortclusters(CoPaMsP[t, ki], McP, smallestClusterSize) CoPaMsN[t, ki] = sortclusters(CoPaMsN[t, ki], McN, smallestClusterSize) # Post-sorting binarisation BP = [ binarise(CoPaMsP[t, ki], binarise_techniqueP, binarise_paramP[p]) for p in range(NPp) ] McP = [np.sum(BPp, axis=0) for BPp in BP] BN = [ binarise(CoPaMsN[t, ki], binarise_techniqueN, binarise_paramN[p]) for p in range(NNp) ] McN = [np.sum(BNp, axis=0) for BNp in BN] # UNCLES B logic for pp in range(NPp): for pn in range(NNp): B[t, pp, pn, ki] = BP[pp] B[t, pp, pn, ki][np.any(BN[pn], axis=1)] = False # Fill Mc Mc[t, ki] = [None] * Ks[ki] for k in range(Ks[ki]): Mc[t, ki][k] = np.zeros([NPp, NNp]) for pp in range(NPp): for pn in range(NNp): Mc[t, ki][k][pp, pn] = np.sum(B[t, pp, pn, ki][:, k]) # Prepare and return the results: params = dict( params, **{ 'methods': methods, 'setsP': setsPloc, 'setsN': setsNloc, 'dofuzzystretch': dofuzzystretch, 'type': type, 'Ks': Ks, 'NKs': NKs, 'wsets': wsets, 'wmethods': wmethods, 'Ds': Ds, 'L': L, 'CoPaMs': CoPaMs, 'smallestclustersize': smallestClusterSize, 'GDM': GDMloc }) UnclesRes = collections.namedtuple('UnclesRes', ['B', 'Mc', 'params', 'X', 'U']) return UnclesRes(B, Mc, params, Xloc, Uloc)