def random_quaternion(): # based on: https://stackoverflow.com/questions/31600717/how-to-generate-a-random-quaternion-quickly while True: x = random.uniform(-1, 1) y = random.uniform(-1, 1) z = x**2 + y**2 if (z <= 1): break while True: u = random.uniform(-1, 1) v = random.uniform(-1, 1) w = u**2 + v**2 if (w <= 1): break s = np.sqrt((1 - z) / w) return [x, y, s * u, s * v]
def converge(self, data_set, file1): #Membership val randomized #mu = random((len(data_set), 1)) #mu = hstack((mu, 1.-mu)) cluster_num = self.cluster_num if cluster_num==1: mu = [0.3,0.7] mu = [mu]*len(data_set) else: mu = [] for i in range(len(data_set)): nums = [random.uniform(0,1) for x in range(0,cluster_num)] sum = reduce(lambda x,y: x+y, nums) norm = [x/sum for x in nums] mu.append(norm) #mu = mu*(len(data_set)) #print mu m = 2.0 fcm = FuzzyCMeans(data_set, mu, m) converged = fcm(emax=0) mem_vals = fcm.mu for i in range(len(self.overall_data)): self.overall_data[i].append(mem_vals[i][0]) self.overall_data[i].append(mem_vals[i][1]) for i in range(len(mu)): self.overall_data[i].append(mu[i]) self.plot_graph(data_set,converged, file1)
def getOne(self): """选择一个个体""" r = random.uniform(0, self.bounds) for life in self.lives: r -= life.score if r <= 0: return life raise Exception("选择错误", self.bounds)
def choose(self, choices): ''' Return a random :param choices: :return: ''' max = sum(choices.values()) pick = random.uniform(0, max) current = 0 for key, value in choices.items(): current += value if current > pick: return key
def particlefilter(self, sequence, pos, stepsize, n): seq = iter(sequence) x = np.ones((n, 2), int) * pos #Initial position f0 = seq.next()[tuple(pos)] * np.ones(n) # Target color model yield pos, x, np.ones(n) / n for im in seq: x += random.uniform(-stepsize, stepsize, x.shape) # Particle motion model: uniform step x = x.clip(np.zeros(2), np.array(im.shape) - 1).astype(int) # Clip out-of-bounds particles f = im[tuple(x.T)] # Measure particle colors w = 1. / (1. + (f0 - f) ** 2) # Weigght~ inverse quadratic color distance w /= sum(w) # Normalize w yield sum(x.T * w, axis=1), x, w # Return expected position, particles and weights if 1. / sum(w ** 2) < n / 2.: x = x[self.resample(w), :]
def particlefilter(self, sequence, pos, stepsize, n): seq = iter(sequence) x = np.ones((n, 2), int) * pos #Initial position f0 = seq.next()[tuple(pos)] * np.ones(n) # Target color model yield pos, x, np.ones(n) / n for im in seq: x += random.uniform(-stepsize, stepsize, x.shape) # Particle motion model: uniform step x = x.clip(np.zeros(2), np.array(im.shape) - 1).astype( int) # Clip out-of-bounds particles f = im[tuple(x.T)] # Measure particle colors w = 1. / (1. + (f0 - f)**2) # Weigght~ inverse quadratic color distance w /= sum(w) # Normalize w yield sum( x.T * w, axis=1 ), x, w # Return expected position, particles and weights if 1. / sum(w**2) < n / 2.: x = x[self.resample(w), :]
for thisComponent in BlankWaitComponents: if hasattr(thisComponent, "setAutoDraw"): thisComponent.setAutoDraw(False) # ------Prepare to start Routine "Focal"------- t = 0 FocalClock.reset() # clock frameN = -1 continueRoutine = True # update component parameters for each repeat from psychopy import visual, core from PIL import Image import numpy as np import glob, os, random, copy, time randomTime = random.uniform(1, 2) f1 = Image.open('./FocalPic.png', 'r') visual.ImageStim(win, f1).draw() win.flip() core.wait(randomTime) # keep track of which components have finished FocalComponents = [] for thisComponent in FocalComponents: if hasattr(thisComponent, 'status'): thisComponent.status = NOT_STARTED # -------Start Routine "Focal"------- while continueRoutine: # get current time t = FocalClock.getTime() frameN = frameN + 1 # number of completed frames (so 0 is the first frame)
def create(input_neuron,output_neuron): synapse = Synapse() # weight=random.uniform(0.078, 0.78) weight=random.uniform(-1, 1) synapse.add_connection(input_neuron,weight,output_neuron) return synapse
def create_bias(bias,neuron): synapse = Synapse() weight=random.uniform(-0.5,0.5) synapse.add_connection(bias,weight,neuron) return synapse
currentLoop = trials # abbreviate parameter names if possible (e.g. rgb = thisTrial.rgb) if thisTrial != None: for paramName in thisTrial.keys(): exec(paramName + '= thisTrial.' + paramName) #------Prepare to start Routine "select"------- t = 0 selectClock.reset() # clock frameN = -1 # update component parameters for each repeat import random from threading import Timer repsLeft = 0 repsRight = 0 preTargetDuration = random.uniform(0.5, 3) if random.randint(0, 1) == 0: repsLeft = 1 repsRight = 0 else: repsLeft = 0 repsRight = 1 #side = 'left' if repsLeft else 'right' #def send(): # sendEvent('attention', side) #Timer(2, send).start() # keep track of which components have finished
def createFractals(experimentStructure, outcomeStructure, stimuliStructure, redFractal, targetPatch, corrAns, trials, outcomes, feedbackText, misses, missCounter, myCount, routineTimer, globalClock, nTrials): """ This function creates the fractals Input: experimentStructure: all general experimental properties outcomeStructure: all general outcome properties stimuliStructure: all general stimulus properties redFractal: position of red fractal (from xls block files) targetPatch: position of the patch that should be identified (from xls block files) corrAns: indicates which button should be pressed (up vs. down) trials: trial handler Psychopy object instance outcome: outcome if anwer is correct (from xls block files) feedbackText: feedback text object instance misses: temporarily saves information about trials that have been missed to repeat these trials missCounter: counter for number of misses myCount: counter for total number of completed trials (if missed trials exist, can be larger than nTrials) routineTimer: timer to control presentation times globalClock: clock to control timing during fMRI nTrials: number of trials Return: decision2: decision2 object instance trials: trial handler Psychopy object instance misses: temporarily saves information about trials that have been missed to repeat these trials missCounter: counter for number of misses routineTimer: timer to control presentation times globalClock: clock to control timing during fMRI decision2.timestamp: indicates decision2 onset fixCrossTiming: actual presentation time of fixation cross during fractal phase feedbackTimestamp: indicates feedback onset fixCrossTiming_feedback: actual presentation time of fixation cross during feedback missIndex: indicates if current trial was missed """ # Create some shortnames NOT_STARTED = experimentStructure['NOT_STARTED'] STARTED = experimentStructure['STARTED'] FINISHED = experimentStructure['FINISHED'] STOPPED = experimentStructure['STOPPED'] endExpNow = experimentStructure['endExpNow'] event = experimentStructure['event'] win = experimentStructure['win'] whichVersion = experimentStructure['whichVersion'] winFeedback = outcomeStructure['winFeedback'] neutralFeedback = outcomeStructure['neutralFeedback'] reward = outcomeStructure['reward'] noReward = outcomeStructure['noReward'] fractalClock = stimuliStructure['fractalClock'] fractal1 = stimuliStructure['fractal1'] fractal2 = stimuliStructure['fractal2'] fixationCross = stimuliStructure['fixationCross'] fixCrossTiming = stimuliStructure['fixCrossTiming'] jitter = stimuliStructure['jitter'] stimulusTiming = stimuliStructure['stimulusTiming'] feedbackClock = stimuliStructure['feedbackClock'] #------Prepare to start Routine "decision2"------- t = 0 fractalClock.reset() frameN = -1 currentJitter = random.uniform(0, jitter) fixCrossTiming = fixCrossTiming + currentJitter routineTimer.add(fixCrossTiming + stimulusTiming) # Compute position of fractals if redFractal == 'up': fractal1.setPos([0, -4]) fractal2.setPos([0, 4]) elif redFractal == 'down': fractal1.setPos([0, 4]) fractal2.setPos([0, -4]) # Get correct keys if whichVersion == 1: if redFractal == 'up': redFractalKey = 'up' blueFractalKey = 'down' elif redFractal == 'down': redFractalKey = 'down' blueFractalKey = 'up' elif whichVersion == 2: if redFractal == 'up': redFractalKey = '4' blueFractalKey = '2' elif redFractal == 'down': redFractalKey = '2' blueFractalKey = '4' if whichVersion == 1: corrAnsKey = corrAns elif whichVersion == 2: if corrAns == 'up': corrAnsKey = '4' elif corrAns == 'down': corrAnsKey = '2' decision2 = event.BuilderKeyResponse( ) # create an object of type KeyResponse decision2.status = NOT_STARTED # Keep track of which components have finished decision2Components = [] decision2Components.append(fixationCross) decision2Components.append(fractal1) decision2Components.append(fractal2) decision2Components.append(decision2) for thisComponent in decision2Components: if hasattr(thisComponent, 'status'): thisComponent.status = NOT_STARTED #-------Start Routine "decision2"------- decision2.timestamp = globalClock.getTime() missIndex = 0 continueRoutine = True while continueRoutine and routineTimer.getTime() > 0: # Get current time t = fractalClock.getTime() frameN = frameN + 1 # number of completed frames (so 0 is the first frame) # *fixationCross* updates if t >= 0.0 and fixationCross.status == NOT_STARTED: # keep track of start time/frame for later fixationCross.tStart = t # underestimates by a little under one frame fixationCross.frameNStart = frameN # exact frame index fixationCross.setAutoDraw(True) if fixationCross.status == STARTED and t >= ( 0.0 + (fixCrossTiming + stimulusTiming - win.monitorFramePeriod * 0.75)): #most of one frame period left fixationCross.setAutoDraw(False) # *fractal1* updates if t >= fixCrossTiming and fractal1.status == NOT_STARTED: # keep track of start time/frame for later fractal1.tStart = t # underestimates by a little under one frame fractal1.frameNStart = frameN # exact frame index fractal1.setAutoDraw(True) if fractal1.status == STARTED and t >= ( fixCrossTiming + (stimulusTiming - win.monitorFramePeriod * 0.75)): #most of one frame period left fractal1.setAutoDraw(False) # *fractal2* updates if t >= fixCrossTiming and fractal2.status == NOT_STARTED: # keep track of start time/frame for later fractal2.tStart = t # underestimates by a little under one frame fractal2.frameNStart = frameN # exact frame index fractal2.setAutoDraw(True) if fractal2.status == STARTED and t >= ( fixCrossTiming + (stimulusTiming - win.monitorFramePeriod * 0.75)): #most of one frame period left fractal2.setAutoDraw(False) # *decision2* updates if t >= fixCrossTiming and decision2.status == NOT_STARTED: # keep track of start time/frame for later decision2.tStart = t # underestimates by a little under one frame decision2.frameNStart = frameN # exact frame index decision2.status = STARTED # keyboard checking is just starting decision2.clock.reset() # now t=0 event.clearEvents(eventType='keyboard') if decision2.status == STARTED and t >= ( fixCrossTiming + (stimulusTiming - win.monitorFramePeriod * 0.75)): #most of one frame period left decision2.status = STOPPED if decision2.status == STARTED: if whichVersion == 1: theseKeys = event.getKeys(keyList=['up', 'down']) elif whichVersion == 2: theseKeys = event.getKeys(keyList=['4', '2']) # Check for quit: if "escape" in theseKeys: endExpNow = True if len(theseKeys) > 0: # at least one key was pressed decision2.keys = theseKeys[-1] # just the last key pressed decision2.rt = decision2.clock.getTime() # Which response? if (decision2.keys == str(redFractalKey)) or (decision2.keys == redFractalKey): decision2.color = 1 else: decision2.color = 2 # Was the answer correct? if (decision2.keys == str(corrAnsKey)) or (decision2.keys == corrAnsKey): decision2.corr = 1 else: decision2.corr = 0 for thisComponent in decision2Components: if hasattr(thisComponent, "status") and thisComponent.status != FINISHED: continueRoutine = True break # at least one component has not yet finished else: continueRoutine = False # Check for quit (the Esc key) if endExpNow or event.getKeys(keyList=["escape"]): core.quit() # Refresh the screen if continueRoutine: # don't flip if this routine is over or we'll get a blank screen win.flip() #-------Ending Routine "decision2"------- for thisComponent in decision2Components: if hasattr(thisComponent, "setAutoDraw"): thisComponent.setAutoDraw(False) # Check responses # --------------- if decision2.keys in ['', [], None]: decision2.keys = None decision2.color = float('nan') if str(corrAns).lower() == 'none': decision2.corr = float('nan') decision2.rt = float('nan') else: decision2.corr = float('nan') decision2.rt = float('nan') if (decision2.keys is None): decision2.reward = noReward msg = "Zu langsam!" if myCount < nTrials: misses.append(myCount) missCounter = missCounter + 1 missIndex = 1 elif (decision2.corr == 1): if float(outcomes) == 1: decision2.reward = reward msg = winFeedback else: decision2.reward = noReward msg = neutralFeedback elif (decision2.corr == 0): if float(outcomes) == 1: decision2.reward = noReward msg = neutralFeedback else: decision2.reward = reward msg = winFeedback # Store data for trials (TrialHandler) trials.addData('decision2.rt', decision2.rt) trials.addData('decision2.keys', decision2.keys) trials.addData('decision2.corr', decision2.corr) trials.addData('decision2.color', decision2.color) trials.addData('decision2.reward', decision2.reward) accPerf = trials.data['decision2.reward'].sum() trials.addData('decision2.accPerf', accPerf) # Give feedback (routineTimer, globalClock, feedbackTimestamp, fixCrossTiming_feedback) = giveFeedback(experimentStructure, stimuliStructure, feedbackText, msg, routineTimer, globalClock, missIndex) return (decision2, trials, misses, missCounter, routineTimer, globalClock, decision2.timestamp, fixCrossTiming, feedbackTimestamp, fixCrossTiming_feedback, missIndex)
def selectJrand(i,m): j=i while (j == i): j = int(random.uniform(0,m)) return j
trial_loop.addData('trial_txt.started', trial_txt.tStartRefresh) trial_loop.addData('trial_txt.stopped', trial_txt.tStopRefresh) # check responses if trial_resp.keys in ['', [], None]: # No response was made trial_resp.keys = None trial_loop.addData('trial_resp.keys', trial_resp.keys) if trial_resp.keys != None: # we had a response trial_loop.addData('trial_resp.rt', trial_resp.rt) trial_loop.addData('trial_resp.started', trial_resp.tStartRefresh) trial_loop.addData('trial_resp.stopped', trial_resp.tStopRefresh) # ------Prepare to start Routine "isi"------- continueRoutine = True # update component parameters for each repeat import random t_isi = random.uniform(0, 1) # keep track of which components have finished isiComponents = [fix_dot] for thisComponent in isiComponents: thisComponent.tStart = None thisComponent.tStop = None thisComponent.tStartRefresh = None thisComponent.tStopRefresh = None if hasattr(thisComponent, 'status'): thisComponent.status = NOT_STARTED # reset timers t = 0 _timeToFirstFrame = win.getFutureFlipTime(clock="now") isiClock.reset(-_timeToFirstFrame) # t0 is time of first possible flip frameN = -1
#GENERATE RANDOM ANGLE ORDER shuffle(angles) for angle in angles: angleNum = (int(angle / 5) - 1) #PICK RANDOM POSITION, CENTER OR RANDOM PERIPHERY thisPos = random.choice(positions) thisLetter = random.choice(letters) eccentricity = 0 if thisPos > 0: eccentricity = angle #RANDOM STIMULUS ONSET TIME delayTime = random.uniform(1, 5) #SET ANGLE, DISPLAY COORDINATES thisXPos = (0 + ((positionXMult[thisPos]) * angleSpacer[angleNum])) thisYPos = (0 + ((positionYMult[thisPos]) * angleSpacer[angleNum])) #PICK RANDOM LETTER, SET CORRECT KEY correctKeyPress = thisLetter.lower() #SET UP DISPLAY TEXT displayText = visual.TextStim(win=win, name='displayText', text=thisLetter, font='Arial',