Python Region.getOutputVector方法代码示例

# 需要导入模块: from region import Region [as 别名]
# 或者: from region.Region import getOutputVector [as 别名]
def testCount():
	rows = 5
	cols = 5
	coverage = 20
	numbits = 10
	numRounds = 500
	trainingRounds = numRounds/4
	originalInputVector = InputVector(numbits)
	inputVector = InputVector(0)

	predictions = dict()
	#repeat several times to increase activity:
	for i in range(3):
		inputVector.extendVector(originalInputVector)

	desiredLocalActivity = DESIRED_LOCAL_ACTIVITY

	newRegion = Region(rows,cols,inputVector,coverage,desiredLocalActivity)
	outputVector = newRegion.getOutputVector()
	correctBitPredictions = 0
 
	for round in range(numRounds): # This test executes the CLA for a set number of rounds. 
     
		#print("Round: " + str(round))
		# if (round % 2 == 0):
		# 	val = 682
		# else:
		# 	val = 341
		val = Ultrasonic(brick, PORT_1).get_sample()
		setInput(originalInputVector,val)
		inputString = inputVector.toString()
		outputString = outputVector.toString()
		#print(originalInputVector.toString())
           
		#for bit in originalInputVector.getVector():
		# 	print(bit.bit)
		# print('')
		# print(inputString)


		if outputString in predictions:
			currentPredictionString = predictions[outputString]
		else:
			currentPredictionString = "[New input]"
		pred[outputString] = inputString
		print("Round: %d" % round) # Prints the number of the round
		printStats(inputString, currentPredictionString)
		if (round > trainingRounds):
			correctBitPredictions += stringOverlap(currentPredictionString, predictions[outputString])
				 

		newRegion.doRound()
		printColumnStats(newRegion)
	for key in predictions:
		print("key: " + key + " predictions: " + predictions[key])

	print("Accuracy: " + str(float(correctBitPredictions)/float((30*(numRounds-trainingRounds)))))

# 需要导入模块: from region import Region [as 别名]
# 或者: from region.Region import getOutputVector [as 别名]
def testCount():
  rows = 5
	cols = 5
	coverage = 20
	numbits = 10 # I may need more bits for my readngs.
	numRounds = 500
	trainingRounds = numRounds/4
	originalInputVector = InputVector(numbits)
	inputVector = InputVector(0)
	predictions = dict()
 
     # Repeat several times to increase activity:
     # Seems to just extend the number of elements in inputVector by numbits (10) 3 times. 
     # Why not extend it by 3*numbits?
     # I think becuase rather than make it 3 times as long, it actually repeats the vector three times,
     # probably so as to, as said above, increase activity in those cells and aid learning. 
     # Good old repartition. In which case, I'm not sure I want to use this in my tests...
	for i in range(3): 
		inputVector.extendVector(originalInputVector)
     
     # Get a non-local variable and feed it to a local one for local manipulation.
	desiredLocalActivity = DESIRED_LOCAL_ACTIVITY
     
     # This sets up a new region, called newRegion,
     # a variable called ouputVector, which calls a method to find just that,
     # and a variable for the number of correct prodicitons, initialised as 0. 
	newRegion = Region(rows,cols,inputVector,coverage,desiredLocalActivity)
	outputVector = newRegion.getOutputVector()
	correctBitPredictions = 0
 
 
      # This is where the action starts. This loop forms the main body of the test.
      # For every time round, an input is given, the CLA updates spacial and temporal 
      # poolers with this new input and an output is found. 
	for round in range(numRounds): 
           # The old version gave two inputs alternatly. The aim was to get the CLA to 
           # predict one of two numbers. 
		#print("Round: " + str(round))
		# if (round % 2 == 0):
		# 	val = 682
		# else:
		# 	val = 341
		val = Ultrasonic(brick, PORT_1).get_sample() # Instead I'm now feeding in readings from the sonar. 
		setInput(originalInputVector,val) # These next few lines convert the inputs and outputs from integers to bitstrings,
		inputString = inputVector.toString() # so that the CLA can handle them. 
		outputString = outputVector.toString()
		#print(originalInputVector.toString())
           
		#for bit in originalInputVector.getVector():
		# 	print(bit.bit)
		# print('')
		# print(inputString)


		if outputString in predictions: # predictions was set up at the start, you might have missed it. 
			currentPredictionString = predictions[outputString]
		else:
			currentPredictionString = "[New input]"
			predictions[outputString] = inputString # I'm sure this line should be here. It's not indented in the origonal. 
   
		print("Round: %d" % round) # Prints the number of the round
		printStats(inputString, currentPredictionString)
  
		if (round > trainingRounds): 
			correctBitPredictions += stringOverlap(currentPredictionString, predictions[outputString])
				 

		newRegion.doRound() # The CLA bit!
		printColumnStats(newRegion) 
  
      
      # With the experiment now over, stat summaries are now printed. 
	for key in predictions:
		print("key: " + key + " predictions: " + predictions[key])
	print("Accuracy: " + str(float(correctBitPredictions)/float(30*(numRounds-trainingRounds))))

# 需要导入模块: from region import Region [as 别名]
# 或者: from region.Region import getOutputVector [as 别名]
def experiment():
    rows = 5
    cols = 5
    coverage = 20
    numbits = 10 # I may need more bits for my readngs.
    numRounds = 10
    numRuns = 1
    minimum_distance = 7
    #trainingRounds = numRounds/4
    accuracies = []
    sonarPositionResults = []
    originalInputVector = InputVector(numbits)
    inputVector = InputVector(0)
    predictions = dict()
    state = "Going Forwards"

 
    # Repeat several times to increase activity:
    # Seems to just extend the number of elements in inputVector by numbits (10) 3 times. 
    # Why not extend it by 3*numbits?
    # I think becuase rather than make it 3 times as long, it actually repeats the vector three times,
    # probably so as to, as said above, increase activity in those cells and aid learning. 
    # Good old repartition. In which case, I'm not sure I want to use this in my tests...
    for i in range(3): 
        inputVector.extendVector(originalInputVector)
    
    # Get a non-local variable and feed it to a local one for local manipulation.
    desiredLocalActivity = DESIRED_LOCAL_ACTIVITY
    
    # This sets up a new region, called newRegion,
    # a variable called ouputVector, which calls a method to find just that,
    # and a variable for the number of correct prodicitons, initialised as 0. 
    newRegion = Region(rows,cols,inputVector,coverage,desiredLocalActivity)
    outputVector = newRegion.getOutputVector()
    correctBitPredictions = 0
    
    robot = Robot()
    starting_position = robot.sonarReading()
    robot.move()
 

    # This is where the action starts. This loop forms the main body of the test.
    # For every time round, an input is given, the CLA updates spacial and temporal 
    # poolers with this new input and an output is found.    
    for round in range(numRounds): 
        if state == "Kill Switch: Engage!":
            break
        end_this_round = False
        stuck_counter = 0
        print state
        round_number = round+1
        print ("Round: %d" % round_number) # Prints the number of the round
            #printStats(inputString, currentPredictionString)
        robot.move()
        
        while end_this_round is False:            
            val = robot.sonarReading()
            print ("Sonar: %d cm" % val)
            sonarPositionResults.append(robot.currentSonarReading)
            setInput(originalInputVector,val) # These next few lines convert the inputs and outputs from integers to bitstrings,
            inputString = inputVector.toString() # so that the CLA can handle them.
            outputString = outputVector.toString()
             #print(originalInputVector.toString())
                  
       	  #for bit in originalInputVector.getVector():
       	  #print(bit.bit)
       	  #print('')
       	  #print(inputString)       
       
            if outputString in predictions: # If output string has been seen before, 
                currentPredictionString = predictions[outputString] 
                # summon the last input that caused that prediction and make it the "currentPredictionString"? That's confusing...
            else:
                currentPredictionString = "[New input]" # If not seen before, 
            predictions[outputString] = inputString # Update the i/o record with the new relationship 
                            
            #if (round > trainingRounds): 
            correctBitPredictions += stringOverlap(currentPredictionString, predictions[outputString]) 
            #    without training rounds, stringOverlap will be trying to compare binary stings with the string 'New input'. So correct BitPredictions is going to be 0 for a while,
            #    until inputs start repeating.
                
            newRegion.runCLA() # The CLA bit!
            numRuns += 1
            
            #printColumnStats(newRegion) 
            accuracy = float(correctBitPredictions)/float(30*numRuns) 
            # Times thirty becuase it's measuring the correct prediction of BITS not whole bit-strings, and there are 30 bits per input.
            # This makes sense as bits have semantic meaning where as bit-strings dont!
            accuracies.append(accuracy)
            
            if robot.killSwitch() == True: # This will terminate all loops and move to the end of the program
                end_this_round = True
                state = "Kill Switch: Engage!"
                print state
            if state == "Going Forwards":
                if robot.currentSonarReading <= minimum_distance: 
                    stuck_counter += 1
                if stuck_counter == 2:     # This routine confirms that a wall is hit, then sends the robot back to the start position
                    robot.stop()             
                    print "Stuck Reflex"
#.........这里部分代码省略.........