robot.motorVelocity(sleepytime)
robot.motorAcceloration(sleepytime)
robot.sonarReading()
robot.sonarVelocity(sleepytime)
robot.sonarAcceloration(sleepytime)
print robot.currentMotorPosition, robot.currentMotorVelocity, robot.currentMotorAcceloration
print robot.currentSonarReading, robot.currentSonarVelocity, robot.currentSonarAcceloration
print ' '
sonarPositionResults.append(robot.currentSonarReading)
sonarVelocityResults.append(robot.currentSonarVelocity)
sonarAccelorationResults.append(robot.currentSonarAcceloration)
if robot.killSwitch() == True: # This works!
break
if robot.currentSonarReading <= 8:
robot.move(-75)
#robot.stop()
if robot.currentSonarReading >= initialPosition:
robot.move(75)
sleep(sleepytime)
robot.stop()
time = np.arange(0, int(steps*sleepytime), 1) # from 0 to blah, in steps of 1.
plt.figure(1)
plt.subplot(311)
plt.plot(time, sonarPositionResults)
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"
state = "Reversing"
print state
stuck_counter = 0
robot.move(-75)
if state == "Reversing":
if (starting_position-3) < robot.currentSonarReading < (starting_position+3): # Clean this up
state = "Going Forwards"
end_this_round = True
# With the experiment now over, stat summaries are now printed.
# for key in predictions:
# print("key: " + key + " predictions: " + predictions[key])
robot.stop()
#print("Accuracy: " + str(float(correctBitPredictions)/float(30*(numRounds-trainingRounds))))
#code below prints a graph of runs against accuracies
runs = np.arange(1, numRuns, 1)
plt.figure(1)
plt.subplot(211)
plt.grid(True)
plt.plot(runs, accuracies)
plt.plot(runs, accuracies, 'bo')
plt.ylabel('Accuracy (correct preditions/predictions)')
plt.title('Change in CLA accuracy of sonar position prediction')
plt.subplot(212)
plt.grid(True)
plt.plot(runs, sonarPositionResults, 'r-')
plt.plot(runs, sonarPositionResults, 'ro')
plt.ylabel('Sonar Readings (cm)')
plt.xlabel('Number of CLA runs')
plt.show()
