def __helpOP(self) -> None: """ """ # STEP 0: Local variables dMenu = {} # STEP 1: Setup - Local variables dMenu = self.__cf.data["help"]["help op"] # STEP 2: User Output print( "Irene (H-OP) {" + Helga.time() + "} - The following options exist in the Antenna Optimization menu." ) for i in range(0, dMenu["items"]): print(dMenu[str(i)]) print("") # STEP 3: Wait for user to continue input("\t> Continue") os.system("cls") # STEP 4: Return print("Irene (OP) {" + Helga.time() + "} - How would you like to continue?") return
def main(self): """ """ # STEP 0: Local variables # STEP 1: Setup - local variables # STEP 2: User Output print( "Irene (Main) {" + Helga.time() + "} - Welcome. How would you like to start the optimization process?" ) # STEP 3: User Input while (True): ui = Rae.getUserInput(self.__enum, menu="main") os.system("cls") if (ui == 0): self.__newGeometry() elif (ui == 1): self.__importGeometry() elif (ui == 2): print("Irene (C-Editor) {" + Helga.time() + "} - This functionality is not implemented yet") #TODO elif (ui == 3): self.__helpMain() elif (ui == 4): print("Irene (Exit) {" + Helga.time() + "} - Bye.") break return
def __getUI(self, _lMenu: list, _bBreakOnInvalid: bool) -> int: """ """ # STEP 0: Local variables # STEP 1: Setup - Local Variables # STEP 2: User Input while (True): # STEP 3: Output menu for i in range(0, len(_lMenu)): print("\t" + str(i) + ": " + _lMenu[i]) print("") # STEP ..: Wait for user input ui = input("\t>") os.system("cls") # STEP 4: Verify input to be type integer try: # STEP 5: Try to cast to int ui = int(ui) # STEP 6: Check that the int is in range if ((ui >= 0) and (ui < len(_lMenu))): # STEP 7: Return return ui elif (_bBreakOnInvalid): return -1 else: # STEP 8: Not in range print("Rae {" + Helga.time() + "} - Invalid Input") except: if (_bBreakOnInvalid): break print("Rae (Menu-UI) {" + Helga.time() + "} - Invalid Input") return -1 # # endregion # #endregion # #endregion
def __getParams(self) -> list: """ """ # STEP 0: Local variables cfTmp = Conny() lMenu = [] lOut = [] # STEP 1: Setup - Local variables cfTmp.load(self.__enum.value) lMenu = cfTmp.data["menus"]["params"] # STEP 2: Iterate through params for i in range(0, lMenu["items"]): # STEP 3: Check if substrate if (i == 2): lOut.append(self.__getSubstrate()) elif (i == 3): lOut.append(self.__getSubstrateHeight()) else: print("Irene (NG) {" + Helga.time() + "} - Please define (" + lMenu[str(i)] + ") {cm}") # STEP 4: User input while (True): # STEP 5: Wait for input ui = input("\t>") os.system("cls") # STEP 6: Verify input try: # STEP 7: Cast to float ui = float(ui) lOut.append(ui) break except: print("Irene (NG) {" + Helga.time() + "} - Invalid Input") return lOut
def __getSubstrateHeight(self) -> float: """ """ # STEP 0: Local variables lTmpMenu = self.__cf.data["menus"]["substrate heights"] # STEP 1: Setup - Local variables # STEP 2: User Output print( "Irene (NG) {" + Helga.time() + "} - Please choose one of the following default substrate heights") # STEP 3: User Input while (True): # STEP 4: Output menu for i in range(0, lTmpMenu["items"]): print("\t" + str(i) + ": " + str(lTmpMenu[str(i)]) + " {mm}") print("") # STEP 5: Wait for input ui = input("\t>") os.system("cls") # STEP 6: Verify input try: # STEP 7: Cast to int ui = int(ui) # STEP 8: Verify range if ((ui >= 0) and (ui < lTmpMenu["items"])): return lTmpMenu[str(ui)] else: print("Irene (NG) {" + Helga.time() + "} - Invalid Input") except: print("Irene (NG) {" + Helga.time() + "} - Invalid Input") return 0.0
def __getFreq(self) -> list: """ """ # STEP 0: Local variables cfTmp = Conny() lMenu = [] lOut = [] # STEP 1: Setup - Local variables cfTmp.load(self.__enum.value) lMenu = cfTmp.data["menus"]["frequency"] # STEP 2: Get frequency menu for i in range(0, lMenu["items"]): # STEP 3: User output print("Irene (NG) {" + Helga.time() + "} - Please define (" + lMenu[str(i)] + ")") # STEP 4: user input while (True): # STEP 5: Wait for input ui = input("\t>") os.system("cls") # STEP 6: Verify input try: # STEP 7: Cast to float ui = float(ui) lOut.append(ui) break except: print("Irene (NG) {" + Helga.time() + "} - Invalid Input") # STEP 8: Return return lOut
def main(self): """ """ # STEP 0: Local variables # STEP 1: Setup - Local variables # STEP 2: User Output print("Heimi (Main) {" + Helga.time() + "} - Hi. What program would you like to run?") # STEP 3: User Input while (True): ui = Rae.getUserInput(self.__enum, menu="main") os.system("cls") if (ui == 0): # STEP 4: If OMA then send to Irene print("Heimi (Main.OMA) + {" + Helga.time() + "} - Transferring control to Irene. See you soon.") irene = Irene() irene.main() print("Hiemi (Main.OMA) + {" + Helga.time() + "} - Welcome back.") elif (ui == 1): # STEP 5: Ha, jokes on you. There is no help for you print("Heimi (Main.Help) {" + Helga.time() + "} - Ummmm, really? Lol") elif (ui == 2): # STEP 6: Exit program print("Heimi (Main.Exit) {" + Helga.time() + "} - Exiting program.") break # STEP 7: Return return
def __psoMapping__(self, **kwargs) -> dict: """ Description: Maps the passed surrogate using Particle-Swarm Optimization. |\n |\n |\n |\n |\n |\n Arguments: + surrogate = ( vars) The surrogate instance to be mapped ~ Required + data = ( vars ) A Data container that contains the data for the mapping process ~ Required """ # STEP 0: Local variables vData = None vSRG = None vSwarm = None dPSO_Params = None lCandidates = [] lFitness = [] # STEP 1: Setup - Local variables # region STEP 2->5: Error checking # STEP 2: Check if surrogate arg passed if ("surrogate" not in kwargs): # STEP 3: Error handling raise Exception("An error occured in Sarah.__psoMapping__() -> Step 2: No surrogate arg passed") # STEP 4: Check if data arg passed if ("data" not in kwargs): # STEP 5: Error handling raise Exception("An error occured in Sarah.__psoMapping__() -> Step 4: No data arg passed") # # endregion # region STEP 6->11: Setup - Local variables # STEP 6: Update - Local variables vData = kwargs["data"] vSRG = kwargs["surrogate"] # STEP 7: Get PSO params dPSO_Params = self.__getParams__(optimizer=sw.PSO)["mapping"] # STEP 8: Get initial candidate iTmp_Candidate = vData.getInputWidth() lTmp_Candidate = [] for _ in range(0, iTmp_Candidate): lTmp_Candidate.append(0.0) lCandidates = self.__getCandidates__(optimizer=sw.PSO, params=dPSO_Params, initial=lTmp_Candidate) vData.reset() for i in range(0, vData.getLen()): lCandidates.append(vData.getRandDNR()["in"]) dPSO_Params["candidates"] = len(lCandidates) # STEP 9: Loop through candidates for i in range(0, len(lCandidates)): # STPE 10: Get candidate fitness lFitness.append( vSRG.getPointOutput( lCandidates[i] ) ) # STEP 11: Setup - Swarm chan vSwarm = SwarmChan(dPSO_Params["candidates"]) vSwarm.initPsoPositions(lCandidates) vSwarm.initPsoFitness(lFitness) vSwarm.initPsoParams(dPSO_Params["phi1"], dPSO_Params["phi2"], dPSO_Params["eta"]) # # endregion # STEP 12: User output if (self.bShowOutput): print("Sarah (map-srg-pso) {" + Helga.time() + "} - Starting Particle-Swarm Optimization mapping") # STEP 13: Iterate for i in range(0, dPSO_Params["iterations"] + 1): # STEP 14: Setup - Local variables lCandidates = [] lFitness = [] # STEP 15: Perform swarming vSwarm.pso() # STEP 16: Iterate through candidates for j in range(0, dPSO_Params["candidates"]): # STPE 17: Get particle fitness vSwarm.lParticles[j].lCurrPosition = self.__limit_candidate_to_trust_region__(candidate=vSwarm.lParticles[j].lCurrPosition) lFitness.append( vSRG.getPointOutput( vSwarm.lParticles[j].lCurrPosition ) ) # STEP 18: Update swarm fitness vSwarm.setParticleFitness(lFitness) # STEP 19: User output if (self.bShowOutput): print("Sarah (map-srg-PSO) {" + Helga.time() + "} - Particle-Swarm Optimzation mapping completed") print("\tTotal Iterations: " + str(i)) # STEP 18: Populate output dictionary dOut = { "result": vSwarm.lBestSolution, "fitness": vSwarm.fBestSolution, "iterations": i } # STEP 19: Return return dOut
def __map_srgOverseer__(self, **kwargs) -> None: """ Description: Maps the fittest surrogate as well as all the other surrogates whose fitness were within the required range |\n |\n |\n |\n |\n Arguments: + data = ( vars ) A Data container containing the dataset to be used during the mapping process ~ Required """ # STEP 0: Local variables optimizer = Hermione() optimizer.bShowOutput = False self.vBest = None self.vFitness = np.inf fTmp_Fitness = np.inf # STEP 1: Setup - Local variables self.lMap_Results = [] self.lMap_Fitness = [] # STEP 2: Check if data arg passed if ("data" not in kwargs): # STEP 3: Error handling raise Exception("An error occured in Golem.__map_srgOverseer__() -> Step 2: No data arg passed") # STEP 5: If optimizer output if (optimizer.bShowOutput): print("") else: print("\t{" + Helga.time() + "} - Starting surrogate mapping\t\t\t-> ", end="") try: # STEP 6: Loop through surrogates for i in range(0, len(self.__lSRG)): # STEP 7: Setup - Scope varibales dTmp_MapResults = None # STEP 8: Best candidate if (i == 0): # STEP 9: Outsource threaded mapping dTmp_MapResults = optimizer.mapSurrogate(threading=False, data=kwargs["data"], surrogate=self.__lSRG[i]) # STEP 10: Else if accuracy = 100% elif ((self.__lSRG_Accuracy[i] == 1.0) or (self.__lSRG_FItness[i] == self.__lSRG_FItness[0])): # STEP 11: Outsource mapping dTmp_MapResults = optimizer.mapSurrogate(threading=False, data=kwargs["data"], surrogate=self.__lSRG[i]) # STPE 12: CHeck if there are results if (dTmp_MapResults != None): # STEP 13: Append to results self.lMap_Results.append(dTmp_MapResults["result"]) self.lMap_Fitness.append(dTmp_MapResults["fitness"]) # STEP 14: Check - Optimizer output status if (optimizer.bShowOutput == False): # STEP 15: Check if new results are best if (dTmp_MapResults["fitness"] < fTmp_Fitness): # STEP 16: Update - Local variables fTmp_Fitness = dTmp_MapResults["fitness"] # STEP 17: User output print("!", end="") # STEP 18: Not new best else: # STEP 19: User output print(".", end="") # STEP 14: Setup - Best results self.vBest = self.lMap_Results[0] self.vFitness = self.lMap_Fitness[0] except Exception as ex: print("Initial error: ", ex) print("An error occured in Golem.__map_srgOverseer__()") # STEP 15: Return return
def __train_srgHandler__(self, _eExit, _eGlobal, _eTR, _qTR) -> None: """ Description: Iteratively trains surrogates until it either finds a surrogate that meets the minimum accuracy requirements or until it has trained the maximum amount of surrogates. |\n |\n |\n |\n |\n Arguments: + _eExit = ( mp.Event() ) Global exit event + _eGlobal = ( mp.Event() ) Global thread result event + _eTR = ( mp.Event() ) Surrogate training result event + _qTR = ( mp.Queue() ) Surrogate training result queue """ # STEP 0: Local variables dArgs = _qTR.get()[0] vData = dArgs["data"] lAccuracy = [] lFitness = [] lResults = [] fBest_Fitness = np.inf iBest_Index = 0 print("\t{" + Helga.time() + "} - Starting surrogate training\t\t-> ", end="") # STEP 1: Iterate through max surrogates for i in range(0, dArgs["max"]): # STEP 2: Get new surrogate dSRG = self.__getSurrogate__(region=dArgs["region"]) vSRG = dSRG["surrogate"] # STEP 3 Do necessary pre-training vSRG.bShowOutput = False vSRG.bUse_NoiseInjection = True vSRG.bUse_L1 = True # STEP 4: Train surrogate fTmp_Fitness = None fTmp_Fitness = vSRG.trainSet(cp.deepcopy(vData), advanced_training=False, compare=False) fTmp_Fitness = fTmp_Fitness["fitness"] # STEP 5: Get accuracy and fitness fTmp_Accuracy = vSRG.getAccuracy(data=vData, size=vData.getLen(), full_set=True) fTmp_Fitness = fTmp_Fitness * ( 1.1 - fTmp_Accuracy["percent accuracy"] ) # STEP 6: Append to output lists lAccuracy.append( fTmp_Accuracy["percent accuracy"] ) lFitness.append( fTmp_Fitness ) lResults.append( vSRG ) # STEP 7: Check if fittest surrogate so far if ((fTmp_Fitness < fBest_Fitness) and (fTmp_Accuracy["percent accuracy"] == 1.0)): # STEP 8: Update - Local variables fBest_Fitness = fTmp_Fitness iBest_Index = i # STEP 9: User output - minimal print("!", end="") # STEP 10: Check if 100p accuracy elif (fTmp_Accuracy["percent accuracy"] == 1.0): # STEP 11: Minimal output print(":", end="") # STEP 12: Not 100p but best fitness elif (fTmp_Fitness < fBest_Fitness): # STEP 13: Update - Local variables fBest_Fitness = fTmp_Fitness iBest_Index = i # STEP 14: User output - minimal print("#", end="") # STEP 15: Bad surrogate else: # STEP 16: User outptu - minimal print(".", end="") # STEP 17: Check if fitness below required and min surrogates generated if ((fBest_Fitness < dArgs["acc"]) and (i >= dArgs["min"])): # STEP 18: Exit loop early break # STEP 19: Check if exit even if (_eExit.is_set()): # STEP 20: Exit loop early break print("") # STEP 21: Swap best surrogate to index = 0 vTmp_Swap = lAccuracy[0] lAccuracy[0] = lAccuracy[iBest_Index] lAccuracy[iBest_Index] = vTmp_Swap vTmp_Swap = lFitness[0] lFitness[0] = lFitness[iBest_Index] lFitness[iBest_Index] = vTmp_Swap vTmp_Swap = lResults[0] lResults[0] = lResults[iBest_Index] lResults[iBest_Index] = vTmp_Swap # STEP 22: Populate output dictionary dOut = { "accuracy": lAccuracy, "fitness": lFitness, "results": lResults } # STEP 23: Put output in queue _qTR.put([dOut]) # STEP 24: Set events _eTR.set() _eGlobal.set() # STEP 25: Return return
def __trainSurrogate__(self, **kwargs) -> vars: """ Description: Trains the passed surrogate using thread techniques. If an optimizer is specified, that surrogate will be more likely to be used during the threaded training process. However, if no optimizer is specified then all optimizers will have the same probability of being used. |\n |\n |\n |\n |\n Args: + surrogate = ( vars ) A surrogate class instance ~ Required + data = ( vars ) Data container ~ Required + password = ( int ) Surrogate password ~ Required + optimizer = ( enum ) The enum of the optimizer to be used ~ Default = { Random } |\n Returns: + surrogate = ( vars ) The optimized surrogate instance """ # STEP 0: Local variables eGlobal = None eGlobal_Exit = None eUI_Event = None qUI_Queue = None tUI_Thread = None lUO_Lock = None lThread_Data = [] lThread_Results = [] iThread = 8 iThread_ID = 0 fFittest = np.inf iFittest = 0 # STEP 1: Setup - Local variables # region STEP 2->9: Error checking # STEP 2: Check if data arg passed if ("data" not in kwargs): # STEP 3: Error handling raise Exception("An error occured in Hermione.__trainSurrogate__() -> Step 2: No data arg passed") # STEP 4: Check if surrogate arg passed if ("surrogate" not in kwargs): # STEP 5: Error handling raise Exception("An error occured in Hermione.__trainSurrogate__() -> Step 4: No surrogate arg passed") # STEP 6: Check if optimizer arg passed if ("optimizer" not in kwargs): # STEP 7: Error handling raise Exception("An error occured in Hermione.__trainSurrogate__() -> Step 6: No optimizer arg passed") # STEP 8: Check if password arg passed if ("password" not in kwargs): # STEP 9: Error handling raise Exception("An error occured in Hermione.__trainSurrogate__() -> Step 8: No password arg passed") # # endregion # region STEP 10->12: Setup - Global variables # STEP 10: Setup - Global variables eGlobal = mp.Event() eGlobal.clear() eGlobal_Exit = mp.Event() eGlobal_Exit.clear() # STEP 11: Setup - UI Thread eUI_Event = mp.Event() qUI_Queue = mp.Queue() tUI_Thread = tr.Thread(target=self.__threadUI__, args=(eGlobal_Exit, eGlobal, eUI_Event, qUI_Queue, )) tUI_Thread.daemon = True #tUI_Thread.start() lUO_Lock = mp.RLock() # STEP 12: Setup - Thread data list for _ in range(0, 4): lThread_Data.append(None) # # endregion # STEP 13: User output if (self.bShowOutput): # STEP 14: Acquire lock lUO_Lock.acquire() # STEP 15: print print("Hermione (train-thread) {" + Helga.time() + "} - Starting threaded surrogate training.\n") # STEP 16: Release lUO_Lock.release() # region STEP 17->46: Training process # STEP 17: Loop bish while (True): # region STEP 18->36: Thread creation # STEP 18: Iterate through training events for i in range(0, len(lThread_Data)): # STEP 19: Check if event is currently None if (lThread_Data[i] == None): # STEP 20: Create a new event eTmp_Event = mp.Event() eTmp_Event.clear() # STEP 21: Create new thread dictionary dTmp_Thread = { "surrogate": cp.deepcopy(kwargs["surrogate"]), "data": cp.deepcopy(kwargs["data"]), "optimizer": kwargs["optimizer"], "id": iThread_ID, "password": kwargs["password"], "thread": i } # STEP 22: Create a new queue qTmp_Queue = mp.Queue() qTmp_Queue.put([dTmp_Thread]) # STEP 23: Create new thread tTmp_Thread = mp.Process(target=self.__threadTrain__, args=(eGlobal_Exit, eTmp_Event, qTmp_Queue, lUO_Lock, )) tTmp_Thread.daemon = True tTmp_Thread.start() # STEP 24: Set thread variable lThread_Data[i] = [tTmp_Thread, eTmp_Event, qTmp_Queue] # STEP 25: Set training flag and icnrement thread id iThread_ID += 1 # STEP 26: Event not None else: # STEP 27: Check if thread has exited if (lThread_Data[i][1].is_set() == True): # STEP 28: Clear event lThread_Data[i][1].clear() # STEP 29: Append data lThread_Results.append( lThread_Data[i][2].get()[0] ) # STEP 30: Check if max threads not reached if (iThread_ID < iThread): # STEP 31: Create new thread dictionary dTmp_Thread = { "surrogate": cp.deepcopy(kwargs["surrogate"]), "data": cp.deepcopy(kwargs["data"]), "optimizer": kwargs["optimizer"], "id": iThread_ID, "password": kwargs["password"], "thread": i } lThread_Data[i][2].put( [dTmp_Thread] ) # STEP 32: Create a new thread tTmp_Thread = mp.Process(target=self.__threadTrain__, args=(eGlobal_Exit, lThread_Data[i][1], lThread_Data[i][2], lUO_Lock, )) tTmp_Thread.daemon = True tTmp_Thread.start() # STEP 33: Set thread var lThread_Data[i][0] = tTmp_Thread # STEP 34: Increment thread id iThread_ID += 1 # STEP 35: Check if 16 threads reached if ( len( lThread_Results ) == iThread): # STEP 36: Exit loop break # # endregion # region STEP 37->46: Ui support # STEP 37: Check if ui thread is set if (eUI_Event.is_set() == True): # STEP 38: Clear event eUI_Event.clear() # STEP 39: Check if ui output == "stop" if (qUI_Queue.get()[0] == "exit"): # STEP 40: Set thread joining event eGlobal_Exit.set() #tUI_Thread.join() # STEP 41: Loop through training threads for i in range(0, len( lThread_Data )): # STEP 42: Check if thread is still training if (lThread_Data[i][0].is_alive() == True): # STEP 43: Join thread lThread_Data[i][0].join() # STEP 44: Save results lThread_Results.append( lThread_Data[i][2].get()[0] ) # STEP 45: Reset thread joining event eGlobal_Exit.clear() # STEP 46: Exit loop break # # endregion # # endregion # STEP 47: Iterate through results for i in range(0, len( lThread_Results )): # STEP 48: Check if fitter than current best if (lThread_Results[i]["fitness"] < fFittest): # STEP 49: Set new best candidate fFittest = lThread_Results[i]["fitness"] iFittest = i # STEP 50: Return return lThread_Results[iFittest]
def __threadMap__(self, _eExit, _eTr, _qTr, _lUO) -> None: """ Description: This function outsources the mapping of the surrogate to the appropriate optimization handler after picking the optimizer to use. |\n |\n |\n |\n |\n Parameters: + _eGlobal_Exit = ( mp.Event() ) Event signalling global exit for threads and processes + _eTr = ( mp.Event() ) Event signalling process completion + _qTr = ( mp.Queue() ) The queue onto which the process results should be returned + _lUO = ( mp.RLock() ) The lock for commong user output |\n Returns: + dOut = ( dict ) ~ "result" = ( list ) The list of surrogate inputs that yielded the best results ~ "fitness" = ( float ) The fitness of the best results """ # STEP 0: Local variables dArgs = _qTr.get()[0] dResults = None iThread_ID = Helga.ticks() iThread_AppID = dArgs["thread"] iSwarms_Active = 0 iGA_Active = 0 iOptimizers_Active = 0 # region STEP 1->15: Map using provided optimizer # STEP 1: Check if not random optimizer if (rn.uniform(0.0, 1.0) > 0.3): # STEP 2: Check if optimizer is GA if (ga.isEnum(dArgs["optimizer"])): # STEP 3: User output if (self.bShowOutput): # STEP 4: Get lock _lUO.acquire() # STEP 5: Populate strings list for threaded output print("\t- Assigning SpongeBob to mapping") print("\t- Optimizer: " + str(dArgs["optimizer"])) print("\t- Thread ID: " + str(iThread_ID)) print("\t- Application Thread ID: " + str(iThread_AppID)) print("\t- Time: " + Helga.time() + "\n") # STEP 6: Release lock _lUO.release() # STEP 7: Create new mapper sb = SpongeBob() # STEP 8: Outsource mapping dResults = sb.mapSurrogate(surrogate=dArgs["surrogate"], data=dArgs["data"], optimizer=dArgs["optimizer"]) # STEP 9: Check if swarm if (sw.isEnum(dArgs["optimizer"])): # STEP 10: User output if (self.bShowOutput): # STEP 11: Get lock _lUO.acquire() # STEP 12: Populate strings list for threaded output print("\t- Assigning Sarah to mapping") print("\t- Optimizer: " + str(dArgs["optimizer"])) print("\t- Thread ID: " + str(iThread_ID)) print("\t- Application Thread ID: " + str(iThread_AppID)) print("\t- Time: " + Helga.time() + "\n") # STEP 13: Release lock _lUO.release() # STEP 14: Create new mapper sh = Sarah() # STEP 15: Outsource mapping dResults = sh.mapSurrogate(surrogate=dArgs["surrogate"], data=dArgs["data"], optimizer=dArgs["optimizer"]) # # endregion # region STEP 16->34: Map using random optimizer # STEP 16: Using random optimizer for mapping else: # STEP 17: Update - Local variables iSwarms_Active = sw.getNumActiveSwarms() iGA_Active = ga.getNumActiveGAs() iOptimizers_Active = iSwarms_Active + iGA_Active # STEP 18: Choose a random optimizer iTmp_Optimizer = rn.randint(0, iOptimizers_Active - 1) # STEP 19: Check if swarm: if (iTmp_Optimizer < iSwarms_Active): # STEP 20: Get optimizer enum eTmp_Optimizer = sw.getActiveSwarms()[iTmp_Optimizer] # STEP 21: User output if (self.bShowOutput): # STPE 22: Acquire lock _lUO.acquire() # STEP 23: Populate output strings print("\t- Assigning Sarah to training") print("\t- Optimizer: " + str(eTmp_Optimizer)) print("\t- Thread ID: " + str(iThread_ID)) print("\t- Application Thread ID: " + str(iThread_AppID)) print("\t- Time: " + Helga.time() + "\n") # STEP 24: Release lock _lUO.release() # STEP 25: Create new mapper sh = Sarah() # STEP 26: Outsource dResults = sh.mapSurrogate(surrogate=dArgs["surrogate"], data=dArgs["data"], optimizer=eTmp_Optimizer) # STEP 27: Then ga else: # STEP 28: Get optimizer enum eTmp_Optimizer = ga.getActiveGAs()[iTmp_Optimizer - iSwarms_Active] # STEP 29: User output if (self.bShowOutput): # STEP 30: Acquired lock _lUO.acquire() # STEP 31: Populate output strings print("\t- Assigning SpongeBob to training") print("\t- Optimizer: " + str(eTmp_Optimizer)) print("\t- Thread ID: " + str(iThread_ID)) print("\t- Application Thread ID: " + str(iThread_AppID)) print("\t- Time: " + Helga.time() + "\n") # STEP 32: Release lock _lUO.release() # STEP 33: Create new mapper sb = SpongeBob() # STEP 34: Outsource mapping dResults = sb.mapSurrogate(surrogate=dArgs["surrogate"], data=dArgs["data"], optimizer=eTmp_Optimizer) # # endregion # Step 35: User output if (self.bShowOutput): # STEP 36: Get lock _lUO.acquire() # STEP 37: Create output strings print("\t\t\t\t\t- Thread: " + str(iThread_AppID) + " - <" + str( round( 100.0 * dResults["fitness"], 3 ) ) + ">\n") # STEP 38: Release lock _lUO.release() # STEP 39: Set results _qTr.put([dResults]) # STEP 40: Set exit event _eTr.set() # STEP 41: Return return
def mapSurrogate(self, **kwargs) -> dict: """ Description: Maps the passed surrogate using the passed dataset. |\n |\n |\n |\n |\n Arguments: + data = ( vars ) A Data container instance containing the dataset to be used for mapping ~ Required + surrogate = ( vars ) A surrogate model to map ~ Required + optimizer = ( enum ) The enum of the optimizer to be used during the mapping process ~ Default = PSO + thread = ( bool ) A flag that indicates if threading should be used to map the surrogate ~ Default = False """ # STEP 0: Local variables eOptimizer = sw.PSO bThreading = False # STEP 1: Setup - Local variables # region STEP 2->5: Error checking # STEP 2: Check if data arg passed if ("data" not in kwargs): # STEP 3: Error handling raise Exception("An error occured in Hermione.mapSurrogate() -> Step 2: No data arg passed") # STEP 4: Check if surrogate arg passed if ("surrogate" not in kwargs): # STEP 5: Error handling raise Exception("An error occured in Hermion.mapSurrogate() -> Step 4: No surrogate arg passed") # # endregion # region STEP 6->11: Setup - Local variables # STEP 6: Check if threading arg passed if ("threading" in kwargs): # STEP 7: Check threading status if (kwargs["threading"] == True): # STEP 8: Update - Local variables bThreading = True # STEP 10: Check if optimizer arg passed if ("optimizer" in kwargs): # STEP 11: Update - Local variables eOptimizer = kwargs["optimizer"] # # endregion # STEP 12: Check if optimizer is GA if (ga.isEnum(eOptimizer)): # STEP 13: Check threading status if (bThreading): # STEP 14: User output if (self.bShowOutput): print("Hermione (map-srg) {" + Helga.time() + "} - Starting threaded surrogate mapping") # STEP 15: Outsource and return return self.__mapSurrogate__(surrogate=kwargs["surrogate"], data=kwargs["data"], optimizer=eOptimizer) # STEP 16: Not threaded else: # STEP 17: User output if (self.bShowOutput): print("Hermione (map-srg) {" + Helga.time() + "} - Starting surrogate mapping") # STEP 18: Create new mapper spongebob = SpongeBob() # STEP 19: Outsource and return return spongebob.mapSurrogate(surrogate=kwargs["surrogate"], data=kwargs["data"], optimizer=eOptimizer) # STEP 20: Check if optimizer is swarm elif (sw.isEnum(eOptimizer)): # STPE 21: Check threading status if (bThreading): # STEP 22: User output if (self.bShowOutput): print("Hermione (map-srg) {" + Helga.time() + "} - Starting threaded surrogate mapping") # STEP 23: Outsource and return return self.__mapSurrogate__(surrogate=kwargs["surrogate"], data=kwargs["data"], optimizer=eOptimizer) # STEP 24: Not threaded else: # STEP 25: User output if (self.bShowOutput): print("Hermione (map-srg) {" + Helga.time() + "} - Starting surrogate mapping") # STEP 26: Create new swarm handler sarah = Sarah() # STEP 27: Outsource and return return sarah.mapSurrogate(surrogate=kwargs["surrogate"], data=kwargs["data"], optimizer=eOptimizer) # STEP 29: Unidentified optimizer - Error handling print("Initial error: ", eOptimizer) raise Exception("An error occured in Natalie.mapSurrogate() -> Step 29: Unidentified optimizer")
def mapSurrogate(self, **kwargs) -> dict: """ Description: Maps the passed surrogate using the specified optimizer. |\n |\n |\n |\n |\n Arguments: + surrogate = ( vars ) The surrogate that requires mapping ~ Required + data = ( vars ) A Data container that contains the data for the mapping process ~ Required + optimizer = ( enum ) The optimizer to be used during the mapping process ~ Required """ # STEP 0: Local variables # STEP 1: Setup - Local variables # region STEP 2->7: Error checking # STEP 2: Check if surrogate arg passed if ("surrogate" not in kwargs): # STEP 3: Error handling raise Exception( "An error occured in SpongeBob.mapSurrogate() -> Step 2: No surrogate arg passed" ) # STEP 4: Check if data arg passed if ("data" not in kwargs): # STEP 5: Error handling raise Exception( "An error occured in SpongeBob.mapSurrogate() -> Step 4: No data arg passed" ) # STEP 6: Check if optimizer arg passed if ("optimizer" not in kwargs): # STEP 7: Error handling raise Exception( "An error occured in SpongeBob.mapSurrogate() -> Step 6: No optimizer arg passed" ) # # endregion # STEP 8: Check if TRO if (kwargs["optimizer"] == ga.TRO): # STEP 10: User output if (self.bShowOutput): print("SpongeBob (map-srg) -> (map-srg-TRO) {" + Helga.time() + "}") # STEP 11: Outsource to tro and return return self.__troMapping__(surrogate=kwargs["surrogate"], data=kwargs["data"]) # STEP 12: Unrecognized optimizer - Error handling raise Exception( "An error occured in SpongeBob.mapSurrogate() -> Step 12: Unrecognized optimizer" )
def __getSubstrate(self) -> float: """ """ # STEP 0: Local variables uiChoice = None # STEP 1: Setup - Local variables # STEP 2: User Output print( "Irene (NG) {" + Helga.time() + "} - Would you like to specify the substrate by name per permitivitty?" ) # STEP 3: User Input while (True): print("\t0: By Name") print("\t1: By permitivitty") print("") # STEP 4: Wait for user input ui = input("\t>") os.system("cls") # STEP 5: Validate input try: # STEP 6: Cast to int ui = int(ui) # STEP 7: Verify range if ((ui == 0) or (ui == 1)): uiChoice = ui break else: print("Irene (NG) {" + Helga.time() + "} - Invalid Input") except: print("Irene (NG) {" + Helga.time() + "} - Invalid Input") # STEP 8: If by value if (uiChoice == 1): # STEP 9: User output print( "Irene (NG) {" + Helga.time() + "} - Please choose one of the following default peremitvitties" ) # STEP 10: User input while (True): # STEP 11: Output menu lTmpMenu = self.__cf.data["menus"]["substrate values"] for i in range(0, lTmpMenu["items"]): print("\t" + str(i) + ": " + str(lTmpMenu[str(i)])) print("") # STEP 12: Wait for user input ui = input("\t>") os.system("cls") # STEP 13: Verify input try: # STEP 14: Cast to int ui = int(ui) # STEP 15: Verify range if ((ui >= 0) and (ui < lTmpMenu["items"])): return lTmpMenu[str(ui)] else: print("Irene (NG) {" + Helga.time() + "} - Invalid Input") except: print("Irene (NG) {" + Helga.time() + "} - Invalid Input") # STEP 16: By name elif (ui == 0): # STEP 16: User Output print("Irene (NG) {" + Helga.time() + "} - Please choose on of the following default substrates") # STEP 17: User input while (True): # STEP 18: Output menu lTmpMenu = self.__cf.data["menus"]["substrate names"] for i in range(0, lTmpMenu["items"]): print("\t" + str(i) + ": " + lTmpMenu[str(i)]) print("") # STEP 19: Wait for user input ui = input("\t>") os.system("cls") # STEP 20: Verify input try: # STEP 21: Casst to int ui = int(ui) # STEP 22: Verify range if ((ui >= 0) and (ui < lTmpMenu["items"])): return self.__cf.data["menus"]["substrate values"][str( ui)] else: print("Irene0 (NG) {" + Helga.time() + "} - Invalid Input") except: print("Irene1 (NG) {" + Helga.time() + "} - Invalid Input") return 0.0
def trainSurrogate(self, **kwargs) -> dict: """ Description: Trains the passed surrogate using the specified optimizer. |\n |\n |\n |\n |\n Args: + surrogate = ( vars ) The surrogate instance to be trained ~ Required + data = ( vars ) Data container ~ Required + password = ( int ) The surrogate password ~ Required + optimizer = ( enum ) The optimizer to user during training ~ Required |\n Returns: + dictionary = ( dict ) ~ iterations = ( int ) Number of training iterations ~ surrogate = ( vars ) The trained surrogate ~ scalar = ( float ) The surrogate scalar """ # STEP 0: Local variables # STEP 1: Setup - Local variables # STEP 2: Check if surrogate passed if ("surrogate" not in kwargs): # STEP 3: Error handling raise Exception( "An error occured in SpongeBob.trainSurrogate() -> Step 2: No surrogate passed" ) # STEP 4: Check if data container passed if ("data" not in kwargs): # STEP 5: Error handling raise Exception( "An error occured in SpongeBob.trainSurrogate() -> Step 4: No data container passed" ) # STEP 6: Check if surrogate password passed if ("password" not in kwargs): # STEP 7: Error handling raise Exception( "An error occured in SpongeBob.trainSurrogate() -> Step 6: No surrogate password passed" ) # STEP 8: Check if optimizer passed if ("optimizer" not in kwargs): # STEP 9: Error handlign raise Exception( "An error occured in SpongeBob.trainSurrogate() -> Step 8: No optimizer passed" ) # STEP 10: Check if tro if (kwargs["optimizer"] == ga.TRO): # STEP 11: User Output if (self.bShowOutput): print("SpongeBob (train-srg) -> (train-srg-tro) {" + Helga.time() + "}") # STEP 12: Outsource tro optimization and return return self.__troTraining__(surrogate=kwargs["surrogate"], data=kwargs["data"], password=kwargs["password"]) else: # STEP ??: Error handling raise Exception( "An error occured in SpongeBob.trainSurrogate(): Unimplemented optimizer passed" ) # STEP ??: Return return None
def __psoTraining__(self, **kwargs) -> dict: """ Description: Trains the passed surrogate using Particle-Swarm Optimization. |\n |\n |\n |\n |\n Args: + surrogate = ( vars ) The surrogate instance to be trained ~ Required + data = ( vars ) Data container ~ Required + password = ( int/float ) The surrogate password ~ Required |\n Returns: + dictionary = ( dict ) A dict instance containing ~ surrogate = ( vars ) The trained surrogate ~ iterations = ( int ) The training iterations ~ scalar = ( float ) The surrogate intstance's scalar """ # STEP 0: Local variables surrogate = None password = None dPsoParams = None swarm = None dTrainingData = None dTestingData = None lCandidates = [] lFitness = [] # region STEP 1->6: Error checking # STEP 1: Check if surrogate arg passed if ("surrogate" not in kwargs): # STEP 2: Error handling raise Exception("An error occured in Sarah.__psoTraining__() -> Step 1: No surorgate arg passed") # STEP 3: Check if data arg passed if ("data" not in kwargs): # STEP 4: Error handling raise Exception("An error occured in Sarah.__psoTraining__() -> Stpe 3: No data arg passed") # STEP 5: Check if password arg passed if ("password" not in kwargs): # STEP 6: Error handling raise Exception("An error occured in Sarah.__psoTraining__() -> Step 5: No password arg passed") # # endregion # region STEP 7->17: Setup - Local variables # STEP 7: Init algorithm parameters dPsoParams = self.__getParams__(optimizer=sw.PSO) # STEP 8: Init datasets dTestingData = kwargs["data"].splitData() dTrainingData = dTestingData["training"] dTestingData = dTestingData["testing"] # STEP 9: Set surrogate and password variables surrogate = kwargs["surrogate"] password = kwargs["password"] # STEP 10: Init candidate list lCandidates = self.__getCandidates__(optimizer=sw.PSO, params=dPsoParams, initial=surrogate.getWeights(password=password)) # STEP 11: Init fitness list lFitness = self.__getFitness__(type="surrogate", candidates=lCandidates, surrogate=surrogate, data=dTestingData, password=password) # STEP 12: Init swarm swarm = SwarmChan(dPsoParams["candidates"]) swarm.initPsoPositions( lCandidates ) swarm.initPsoFitness( lFitness ) swarm.initPsoParams( dPsoParams["phi1"], dPsoParams["phi2"], dPsoParams["eta"] ) # STEP 13: Get rand fTmp = rn.uniform(0.0, 1.0) # STEP 14: Check if L1 if (fTmp < 0.65): # STEP 15: Set - L1 surrogate.bUse_L1 = True # STEP 16: Check if L2 elif (fTmp < 0.85): # STPE 17: Set - L2 surrogate.bUse_L2 = True # # endregion # STEP 18: User Output if (self.bShowOutput): print("Sarah (train-srg-pso) {" + Helga.time() + "} - Starting Particle-Swarm Optimization\n") # STEP 19: Perform number of iterations for i in range(0, dPsoParams["iterations"] + 1): # STEP 20: Reset variables lFitness = [] lCandidates = [] # region STEP 5->14: Training process # STEP 5: Perform swarming swarm.pso() # STEP 6: Iterate through all particles for j in range(0, dPsoParams["candidates"]): # STEP 7: Append particle to list swarm.lParticles[j].lCurrPosition = self.__limit_candidate_to_trust_region__(candidate=swarm.lParticles[j].lCurrPosition) lCandidates.append(swarm.lParticles[j].lCurrPosition) # STEP 8: Get updated fitness values lFitness = self.__getFitness__(type="surrogate", candidates=lCandidates, surrogate=surrogate, data=dTestingData, password=password) # STEP 9: Set new particle fitness swarm.setParticleFitness(lFitness) # STEP 10: Set surrogate weights to best candidate surrogate.setWeights(weights=swarm.lBestSolution, password=password) # STEP 11: Perform default training for j in range(0, dPsoParams["iterations-def"]): # STEP 12: Get random data sample dDNR = dTrainingData.getRandDNR(noise=True) # STEP 13: Perform propagation surrogate.propagateForward(data=dDNR["in"], password=password) surrogate.propagateBackward(data=dDNR["out"], password=password) # STEP 14: Update best candidate swarm.lBestSolution = surrogate.getWeights(password=password) # # endregion # STEP 24: Get accuracy as percentage dHold = surrogate.getAccuracy(data=kwargs["data"], size=kwargs["data"].getLen(), full_set=True) iAcc = dHold["accurate samples"] fAcc = dHold["percent accuracy"] # STEP 23: User Output if (self.bShowOutput): # STEP 25: Print output print("\tSarah (train-srg-pso) {" + Helga.time() + "} - Particle-Swarm Optimization Unsuccessful") print("\t\tTotal iterations: " + str(i)) print("\t\tAccurate Samples: " + str(iAcc)) print("\t\tPercent Accuracy: " + str(round(fAcc * 100.0, 2)) + "%\n") # STEP 26: Populate output dictionary dOut = { "accuracy": iAcc, "algorithm": "pso", "iterations": -i, "scalar": dPsoParams["scalar"], "surrogate": surrogate } # STEP 27: Check that iAcc > 0 if (iAcc <= 0): dOut["inverse accuracy"] = np.inf else: dOut["inverse accuracy"] = float(dHold["iterations"] / iAcc) # STEP 28: Return return dOut
def __newGeometry(self) -> None: """ """ # STEP 0: Local variables lParams = None fParent = None # STEP 1: Setup - Local variables # STEP 2: User Output print( "Irene (NG) {" + Helga.time() + "} - Would you like to specify the frequency range or the parameters of the new antenna?" ) # STEP 3: User Input while (True): print("\t0: Frequency Range") print("\t1: Parameters") print("\t2: ~ Help") print("\t3: ~ Exit") print("") # STEP 4: Wait for user input ui = input("\t>") os.system("cls") # STEP 5: Verify input try: # STEP 6: Cast to int ui = int(ui) # STEP 7: Verify range if (ui == 0): # STEP 8: Get frequency range lParams = self.__getFreq() fParent = "frequency" break elif (ui == 1): # STEP 9: Get geometry parameters lParams = self.__getParams() fParent = "params" break elif (ui == 2): self.__helpNG() elif (ui == 3): print("Irene (Main) {" + Helga.time() + "} - How would you like to continue?") return else: print("Irene (NG) {" + Helga.time() + "} - Invalid Input") except Exception as ex: print(ex) print("Irene (NG) {" + Helga.time() + "} - Invalid Input") # STEP 10: Energize self.__optimize(lParams, parent=fParent) # STEP 10: User Output print("Irene (Main) {" + Helga.time() + "} - How would you like to continue?") # STEP 11: Return return
def __importGeometry(self) -> None: """ """ # STEP 0: Local variables cfTmp = Conny() sPath = None lOut = [] # STEP 1: Setup - Local variables # STEP 2: User Output print("Irene (IG) {" + Helga.time() + "} - Please specify the antenna geometry .json file to use.") # STEP 3: User Input while (True): # STEP 4: Wait for input ui = input("\t>") os.system("cls") # STEP ..: Check for import cancel if (ui == "cancel"): print("Irene (Main) {" + Helga.time() + "} - How would you like to continue?") return # STEP ..: Check for help requres if (ui == "help"): self.__helpIG() else: # STEP 5: Check if input contains \\ or / if (("\\" in ui) or ("/" in ui)): # STEP 6: Assume full path - check existence if (os.path.exists(ui)): sPath = ui break else: print("Irene (NG) {" + Helga.time() + "} - Invalid Input") else: # STEP 7: Check in ConfigFiles sTmpPath = os.path.abspath( ".") + "\\Data\\ConfigFiles\\" + ui if (os.path.exists(sTmpPath)): sPath = sTmpPath break # STEP 8: Check Exports sTmpPath = os.path.abspath( ".") + "\\Data\\Exports\\Antennas\\" + ui if (os.path.exists(sTmpPath)): sPath = sTmpPath break # STEP 9: User Output print("Irene (NG) {" + Helga.time() + "} - Invalid Input") # STEP 10: Load the json file cfTmp.load(sPath) # STEP 11: Append the data lOut.append(cfTmp.data["frequency"]["lower"]) lOut.append(cfTmp.data["frequency"]["upper"]) lOut.append(cfTmp.data["params"]["length"]) lOut.append(cfTmp.data["params"]["width"]) lOut.append(cfTmp.data["params"]["substrate height"]) lOut.append(cfTmp.data["params"]["permitivitty"]) # STEP 12: Optimize using parameters self.__optimize(lOut, parent="import") # STEP 13: User Output print("Irene (Main) {" + Helga.time() + "} - How would you like to continue?") # STEP 14: Return return
def __optimize(self, _lParams: list, **kwargs) -> None: """ """ # STEP 0: Local variables fOffset = None bDefault = None # STEP 1: Setup - Local variables # STEP 2: Check if parent was params if (kwargs["parent"] == "params"): # STEP 3: User Output print( "Irene (OP) {" + Helga.time() + "} - Would you like to specify the offset for the band edges from the center frequency?" ) # STEP 4: User Input while (True): # STEP 5: Output menu options print("\t0: Yes") print("\t1: No") print("") # STEP 6: Wait for user input ui = input("\t>") os.system("cls") # STEP 7: Verify input try: # STEP 8: Cast to int ui = int(ui) # STEP 9: Verify range if (ui == 0): # STEP 10: User Output print("Irene (OP) {" + Helga.time() + "} - Please specify the offset in Hz") # STEP 11: User Input while (True): # STEP 11: Wait for user input ui = input("\t>") os.system("cls") # STEP 12: Verify input try: # STEP 13: Cast to float ui = float(ui) fOffset = ui break except: print("Irene (OP) {" + Helga.time() + "} - Invalid Input") break if (ui == 1): fOffset = 100.0 break else: print("Irene (OP) {" + Helga.time() + "} - Invalid Input") except: print("Irene (OP) {" + Helga.time() + "} - Invalid Input") # STEP 2: User Output print( "Irene (OP) {" + Helga.time() + "} - Would you like to use default configurations for this project?" ) # STEP 3: Get some more user input while (True): print("\t0: Use Default Configurations") print("\t1: Don't Use Default Configurations") print("") # STEP 4: Wait for user input ui = input("\t>") os.system("cls") # STEP 5: Verify input try: # STEP 6: Cast to int ui = int(ui) # STEP 7: Verify range if (ui == 0): bDefault = True break elif (ui == 1): bDefault = False break else: print("Irene (OP) {" + Helga.time() + "} - Invalid Input") except: print("Irene (OP) {" + Helga.time() + "} - Invalid Input") # STEP 8: Init Natalie nat = Natalie(_lParams, bDefault, parent=kwargs["parent"], offset=fOffset) # STEP 9: User Output print("Irene (OP) {" + Helga.time() + "} - How would you like to continue?") # STPE 10: User Input while (True): # STEP 11: Output menu options print("\t0: Start Optimization Process") print("\t1: ~ Edit Nat config") print("\t2: ~ Help") print("\t3: ~ Exit") print("") # STEP 12: Wait for user input ui = input("\t>") os.system("cls") # STEP 13: Verify input try: # STEP 14: Cast to int ui = int(ui) # STEP 15: Verify range if (ui == 0): print( "Irene (OP) {" + Helga.time() + "} - Starting Optimization Process, this could take a while." ) break elif (ui == 1): nat.configEditor() print("Irene (OP) {" + Helga.time() + "} - How would you like to continue?") elif (ui == 2): self.__helpOP() elif (ui == 3): return else: print("Irene (OP) + {" + Helga.time() + "} - Invalid Input") except: print("Irene (OP) + {" + Helga.time() + "} - Invalid Input") nat.optimizeAntenna() return
def __troTraining__(self, **kwargs) -> dict: """ Description: Trains the passed surrogate using Trust-Region Optimization. |\n |\n |\n |\n |\n Args: + surrogate = ( vars ) The surrogate instance to be trained ~ Required + data = ( vars ) Data container ~ Required + password = ( int / float ) The surrogate instance's password ~ Required |\n Returns: + dictionary = ( dict ) A dict instance containing ~ surrogate = ( vars ) The trained surrogate ~ iterations = ( int ) The training iterations ~ scalar = ( float ) The surrogate intstance's scalar """ # STEP 0: Local variables surrogate = None password = None dTroParams = None garry = None dTestingData = None lCandidates = [] lFitness = [] # region STEP 1->6: Error checking # STEP 1: Check if surrogate arg passed if ("surrogate" not in kwargs): # STEP 2: Error handling raise Exception( "An error occured in SpongeBob.__troTraining__() -> Step 1: NO surrogate arg passed" ) # STEP 3: Check if data arg passed if ("data" not in kwargs): # STEP 4: Error handling raise Exception( "An error occured in SpongeBob.__troTraining__() -> Step 3: No data arg passed" ) # STEP 5: Check if password arg passed if ("password" not in kwargs): # STEP 6: Error handling raise Exception( "An error occured in SpongeBob.__troTraining__() -> Step 5: No password arg passed" ) # # endregion # region STEP 7->13: Setup - Local variables # STEP 7: Init algorithm parameters dTroParams = self.__getParams__(optimizer=ga.TRO) # STEP 8: Init datasets dTestingData = kwargs["data"].splitData() dData_Train = dTestingData["training"] dData_Test = dTestingData["testing"] # STEP 9: Init surrogate and password variables surrogate = kwargs["surrogate"] password = kwargs["password"] # STEP 10: Init surrogate activation funcitons # STEP 11: Init candidate list lCandidates.append(surrogate.getWeights(password=password)) # STEP 12: Init fitness list lFitness = self.__getFitness__(type="surrogate", candidates=lCandidates, surrogate=surrogate, data=dData_Test, password=password) # STEP 13: Init genetic algorithm garry = Garry(dTroParams["candidates"]) garry.initTroParticles(candidates=lCandidates) garry.initTroFitness(fitness=lFitness) garry.initTroParams(region=dTroParams["region"]) # STPE 14: Check if L1 fTmp = rn.uniform(0.0, 1.0) # STEP 15: Check if L1 if (fTmp < 0.65): # STEP 16: Set - L1 surrogate.bUse_L1 = True # STEP 17: Check if L2 elif (fTmp < 0.85): # STEP 18: Set - L2 surrogate.bUse_L2 = True # # endregion # STEP 14: User Output if (self.bShowOutput): print("SpongeBob (train-srg-tro) {" + Helga.time() + "} - Starting Trust-Region Optimization\n") # STEP 15: Perform specified number of iterations for i in range(0, dTroParams["iterations"] + 1): # STEP 16: Clear necesarry variables lCandidates = [] lFitness = [] # STEP 5: Populate candidate list lCandidates = self.__getCandidates__( optimizer=ga.TRO, params=dTroParams, initial=garry.lTroBest[0].lCurrPosition, region=float(garry.iTroRegion / dTroParams["region"])) # STEP 6: Get candidate list fitness for j in range(0, len(lCandidates)): # STEP 7: Set surrogate weights surrogate.setWeights(weights=lCandidates[j], password=password) # STEP 8: Append candidate fitness lFitness.append(surrogate.getAFitness(data=dData_Test)) # STEP 9: Update garry garry.setPopulation(candidates=lCandidates) garry.setFitness(fitness=lFitness) # STEP 10: Set surrogate weight to best candidate surrogate.setWeights(weights=garry.vBestSolution.lCurrPosition, password=password) # STEP 11: Perform default training for j in range(0, dTroParams["iterations-def"]): # STEP 12: Get random data sample dDNR = dData_Train.getRandDNR(noise=True) # STEP 13: Perform propagation surrogate.propagateForward(data=dDNR["in"], password=password) surrogate.propagateBackward(data=dDNR["out"], password=password) # STEP 14: Update garry garry.vBestSolution.lCurrPosition = surrogate.getWeights( password=password) garry.fBestSolution = surrogate.getAFitness(data=dData_Test) # STEP 15: Perform trust-region optimization garry.tro() # STEP 16: Check if region is still okay if (garry.iTroRegion <= 1): # STEP 17: Exit loop break # STEP 26: Get accuracy as percentage dHold = surrogate.getAccuracy(data=kwargs["data"], size=kwargs["data"].getLen(), full_set=True) iAcc = dHold["accurate samples"] fAcc = dHold["percent accuracy"] # STEP 27: User Output if (self.bShowOutput): # STEP 28: Print output if (fAcc >= dTroParams["requirement"]): print("SpongeBob (train-srg-tro) {" + Helga.time() + "} - Trust-Region Optimization successful") print("\tTotal Iterations: " + str(i)) print("\tAccurate Samples: " + str(iAcc)) print("\tPercent Accuracy: " + str(round(fAcc * 100.0, 2)) + "%\n") else: print("\tSpongeBob (train-srg-tro) {" + Helga.time() + "} - Trust-Region Optimization Unsuccessful") print("\t\tTotal iterations: " + str(i)) print("\t\tAccurate Samples: " + str(iAcc)) print("\t\tPercent Accuracy: " + str(round(fAcc * 100.0, 2)) + "%\n") # STEP 29: Populate output dictionary dOut = { "accuracy": iAcc, "algorithm": "tro", "iterations": -i, "scalar": dTroParams["scalar"], "surrogate": surrogate } # STEP 31: Check that iAcc > 0 if (iAcc <= 0): dOut["inverse accuracy"] = np.inf else: dOut["inverse accuracy"] = float(dHold["iterations"] / iAcc) # STEP 30: Return return dOut
def __threadTrain__(self, _eExit, _eTr, _qTr, _lUO) -> None: """ Description: This fucntion outsources the training of the surrogate to the appropriate optimization handler after finding the optimizer to use. |\n |\n |\n |\n |\n Parameters: + _eGlobal_Exit = ( mp.Event() ) Event signalling global exit for threads and processes + _eTr = ( mp.Event() ) Event signalling process completion + _qTr = ( mp.Queue() ) The queue onto which the process results should be returned + _lUO = ( mp.RLock() ) The lock for commong user output |\n Returns: + dict = ( dict ) ~ surrogate = ( vars ) The trained surrogate ~ fitness = ( float ) The overall fitness of the trained surrogate """ # STEP 0: Local variables dArgs = _qTr.get()[0] dResults = None iThread_ID = Helga.ticks() iThread_AppID = dArgs["thread"] iSwarms_Active = 0 iGA_Active = 0 iOptimizers_Active = 0 # region STEP 1->15: Train using provided optimizer # STEP 1: Check if not random optimizer if (rn.uniform(0.0, 1.0) > 0.3): # STEP 2: Check if optimizer is GA if (ga.isEnum(dArgs["optimizer"])): # STEP 3: User output if (self.bShowOutput): # STEP 4: Get lock _lUO.acquire() # STEP 5: Print output print("\t- Assigning SpongeBob to training") print("\t- Optimizer: " + str(dArgs["optimizer"])) print("\t- Thread ID: " + str(iThread_ID)) print("\t- Application Thread ID: " + str(iThread_AppID)) print("\t- Time: " + Helga.time() + "\n") # STEP 6: Release lock _lUO.release() # STEP 7: Create new optimizer sb = SpongeBob() # STEP 8: Outsoruce training dResults = sb.trainSurrogate(surrogate=dArgs["surrogate"], data=dArgs["data"], password=dArgs["password"], optimizer=dArgs["optimizer"]) # STEP 9: Check if swarm elif (sw.isEnum( dArgs["optimizer"] )): # STEP 10: User Output if (self.bShowOutput): # STEP 11: Get lock _lUO.acquire() # STEP 12: Print strings print("\t- Assigning Sarah to training") print("\t- Optimizer: " + str(dArgs["optimizer"])) print("\t- Thread ID: " + str(iThread_ID)) print("\t- Application Thread ID: " + str(iThread_AppID)) print("\t- Time: " + Helga.time() + "\n") # STEP 13: Release lock _lUO.release() # STEP 14: Create new optimizer sarah = Sarah() # STEP 15: Outsource training dResults = sarah.trainSurrogate(surrogate=dArgs["surrogate"], data=dArgs["data"], password=dArgs["password"], optimizer=dArgs["optimizer"]) # # endregion # region STEP 16->34: Random training # STEP 16: Use random else: # STEP 17: Update - Local variables iSwarms_Active = sw.getNumActiveSwarms() iGA_Active = ga.getNumActiveGAs() iOptimizers_Active = iSwarms_Active + iGA_Active # STEP 18: Random a handler iTmp_Optimizer = rn.randint(0, iOptimizers_Active - 1) # STEP 19: if swarm if (iTmp_Optimizer < iSwarms_Active): # STEP 20: Get new swarm enum eTmp_Optimzier = sw.getActiveSwarms()[iTmp_Optimizer] # STEP 21: User Output if (self.bShowOutput): # STEP 22: Get lock _lUO.acquire() # STEP 23: Print output print("\t- Assigning Sarah to training") print("\t- Optimizer: " + str(eTmp_Optimzier)) print("\t- Thread ID: " + str(iThread_ID)) print("\t- Application Thread ID: " + str(iThread_AppID)) print("\t- Time: " + Helga.time() + "\n") # STEP 24: Release lock _lUO.release() # STEP 25: Create new optimizer sarah = Sarah() # STEP 26: Outsource training dResults = sarah.trainSurrogate(surrogate=dArgs["surrogate"], data=dArgs["data"], password=dArgs["password"], optimizer=eTmp_Optimzier) # STEP 27: Then ga else: # STEP 28: Get new ga enum eTmp_Optimizer = ga.getActiveGAs()[iTmp_Optimizer - iSwarms_Active] # STEP 29: User Output if (self.bShowOutput): # STEP 30: Acquire lock _lUO.acquire() # STEP 31: Print output print("\t- Assigning SpongeBob to training") print("\t- Optimizer: " + str(eTmp_Optimizer)) print("\t- Thread ID: " + str(iThread_ID)) print("\t- Application Thread ID: " + str(iThread_AppID)) print("\t- Time: " + Helga.time() + "\n") # STEP 32: Release lock _lUO.release() # STEP 33: Create new optimizer sb = SpongeBob() # STEP 34: Outsource training dResults = sb.trainSurrogate(surrogate=dArgs["surrogate"], data=dArgs["data"], password=dArgs["password"], optimizer=eTmp_Optimizer) # # endregion # STEP 35: Get surrogate fitness fTmpFitness = dResults["surrogate"].getAFitness(data=dArgs["data"]) fTmpFitness = fTmpFitness * dResults["inverse accuracy"] # STEP 36: User Output if (self.bShowOutput): # STEP 37: Get lock _lUO.acquire() # STEP 38: Print output print("\t\t\t\t\t- Thread: " + str(iThread_AppID) + " - <" + str(dResults["accuracy"]) + " : " + str(round(fTmpFitness, 2)) + ">") print("\t\t\t\t\t- Time: " + Helga.time() + "\n") # STEP 39: release lock _lUO.release() # STEP 40: Populate output dictionary dOut = { "accuracy": dResults["accuracy"], "algorithm": dResults["algorithm"], "fitness": fTmpFitness, "iterations": dResults["iterations"], "inverse accuracy": dResults["inverse accuracy"], "scalar": dResults["scalar"], "surrogate": dResults["surrogate"] } # STEP 41: Set training results _qTr.put([dOut]) # STEP 42: Set training finished result _eTr.set() # STEP 43: Return return # # endregion # #endregion # #endregion #region Testing # #endregion
def __troMapping__(self, **kwargs) -> dict: """ Description: Maps the passed surrogate using Trust-Region Optimization. |\n |\n |\n |\n |\n Arguments: + surrogate = ( vars ) The surrogate instance to be mapped ~ Required + data = ( vars ) A Data container that contains the dataset to be used during the mapping process """ # STEP 0: Local variables vData = None vGarry = None vSRG = None dTRO_Params = None lCandidates = [] lFitness = [] # STEP 1: Setup - Local variables # region STEP 2->5: Error checking # STEP 2: Check if surrogate arg passed if ("surrogate" not in kwargs): # STEP 3: Error handling raise Exception( "An error occured in SpongeBob.__troMapping__() -> Step 2: No surrogate arg passed" ) # STEP 4: CHeck if data arg passed if ("data" not in kwargs): # STEP 5: Error handling raise Exception( "An error occured in SpongeBob.__troMapping__() -> Step 4: No data arg passed" ) # # endregion # region STEP 6->10: Setup - Local variabls # STEP 6: Update - Local variables vData = kwargs["data"] vSRG = kwargs["surrogate"] # STEP 7: Get initial candidate iTmp_Candidate = vData.getInputWidth() lTmp_Candidate = [] for _ in range(0, iTmp_Candidate): lTmp_Candidate.append(0.0) lCandidates.append(lTmp_Candidate) # STEP 8: Get initial fitness lFitness.append(vSRG.getPointOutput(lTmp_Candidate)) # STEP 9: Get TRO params dTRO_Params = self.__getParams__(optimizer=ga.TRO)["mapping"] # STEP 10: Setup - Garry vGarry = Garry(dTRO_Params["candidates"]) vGarry.initTroParticles(candidates=lCandidates) vGarry.initTroFitness(fitness=lFitness) vGarry.initTroParams(region=dTRO_Params["region"]) # # endregion # STEP 11: User output if (self.bShowOutput): print("SpongeBob (map-srg-TRO) {" + Helga.time() + "} - Starting Trust-Region Optimization mapping") # STEP 12: Loop for max iterations for i in range(0, dTRO_Params["iterations"] + 1): # STEP 13: Clear required variables lFitness = [] # STEP 14: Populate candidate list lCandidates = self.__getCandidates__( optimizer=ga.TRO, params=dTRO_Params, initial=vGarry.lTroBest[0].lCurrPosition, region=float(vGarry.iTroRegion / dTRO_Params["region"])) # STEP 15: Loop through candidates for j in range(0, len(lCandidates)): # STEP 16: Get candidate fitness lFitness.append(vSRG.getPointOutput(lCandidates[j])) # STEP 17: Update garry vGarry.setPopulation(candidates=lCandidates) vGarry.setFitness(fitness=lFitness) # STEP 18: Perform trust-region optimization vGarry.tro() # STEP 19: Check if region too small if (vGarry.iTroRegion <= 1): # STEP 20: Exit loop break # STEP 27: User output if (self.bShowOutput): print("SpongeBob (map-srg-TRO) {" + Helga.time() + "} - Trust-Region Optimizaion mapping completed") print("\tTotal Iterations: " + str(i)) # STEP 28: Populate output dictionary dOut = { "result": vGarry.lTroBest[0].lCurrPosition, "fitness": vGarry.lTroBest[1], "iterations": i } # STEP ??: Return return dOut
def trainSurrogate(self, **kwargs) -> vars: """ Description: Trains the passed surrogate using thread techniques if required to do so. If an optimizer is specified, only that optimizer will be used. However, if no optimizer is specified a random optimizer will be used. |\n |\n |\n |\n |\n Args: + surrogate = ( vars ) A surrogate class instance ~ Required + data = ( vars ) Data container ~ Required + password = ( int ) Surrogate pass ~ Required + optimizer = ( enum ) The enum of the optimizer to be used ~ Default = PSO + threading = ( bool ) Multi-treading flag ~ Default = False |\n Returns: surrogate = ( vars ) The trained surrogate """ # STEP 0: Local variables eOptimizer = sw.PSO bThreading = False # STEP 1: Setup - Local variables # region STEP 2->7: Error checking # STEP 2: Check that a surrogate was passed if ("surrogate" not in kwargs): # STEP 3: Error handling raise Exception("An error occured in Hermione.trainSurrogate() -> Step 2: No surrogate passed") # STEP 4: Check that the data container was passed if ("data" not in kwargs): # STEP 5: Error handling raise Exception("An error occured in Hermione.trainSurrogate() -> Step 4: Data container not passed") # STEP 6: Check that the surrogate password was passed if ("password" not in kwargs): # STEP 7: Error handling raise Exception("An error occured in Hermione.trainSurrogate() -> Step 4: Password associated with surrogate not passed") # # endregion # region STEP 8->12: Setup - Local variables # STEP 8: Check if threading was specified if ("threading" in kwargs): # STEP 9: Check if threading enabled if (kwargs["threading"] == True): # STEP 10: Update - Local variables bThreading = True # STEP 11: Check if optimizer was specified if ("optimizer" in kwargs): # STEP 12: Set optimizer eOptimizer = kwargs["optimizer"] # # endregion # STEP 13: Check if optimizer is GA if (ga.isEnum(eOptimizer)): # STEP 14: Check - Threading status if (bThreading): # STEP 15: User output if (self.bShowOutput): print("Hermione (train-srg) {" + Helga.time() + "} - Starting threaded surrogate training") # STEP 16: Outsource and return return self.__trainSurrogate__(surrogate=kwargs["surrogate"], data=kwargs["data"], password=kwargs["password"], optimizer=eOptimizer) # STEP 17: Not threaded else: # STEP 18: User output if (self.bShowOutput): print("Hermione (train-srg) {" + Helga.time() + "} - Starting surrogate training") # STEP 19: Create new optimizer sb = SpongeBob() # STEP 20: Outsource and return return sb.trainSurrogate(surrogate=kwargs["surrogate"], data=kwargs["data"], password=kwargs["password"], optimizer=eOptimizer) # STEP 21: Check if optimizer is swarm if (sw.isEnum(eOptimizer)): # STEP 22: Check - Threading status if (bThreading): # STEP 23: User output if (self.bShowOutput): print("Hermione (train-srg) {" + Helga.time() + "} - Starting threaded surrogate training") # STEP 24: Outsouce and return return self.__trainSurrogate__(surrogate=kwargs["surrogate"], data=kwargs["data"], password=kwargs["password"], optimizer=eOptimizer) # STEP 25: Not threaded else: # STEP 26: User output if (self.bShowOutput): print("Hermione (train-srg) {" + Helga.time() + "} - Starting surrogate training") # STEP 27: Create new optimizer sarah = Sarah() # STEP 28: Outsource and return return sarah.trainSurrogate(surrogate=kwargs["surrogate"], data=kwargs["data"], password=kwargs["password"], optimizer=eOptimizer) # STEP 29: Unidentified optimizer - Error handling print("Initial error: ", eOptimizer) raise Exception("An error occured in Natalie.trainSurrogate() -> Step 29: Unidentified optimizer")