def setWeights(self, weights):
"""
Plot the logistic regression line for given weights
This will draw on the existing pacman window with the existing points
weights: array or list of 2 values (or if just one value, the bias weight is assumed to be zero). If None,
no line is drawn. Default: None
"""
weights = np.array(weights)
if weights.size >= 2:
w = weights[0]
b = weights[1]
else:
w = float(weights)
b = 0
xmin = 1 - self.xShift
xmax = self.width - 2 - self.xShift
x = np.linspace(xmin, xmax, 30)
y = 1.0 / (1 + np.exp(-(w * x + b)))
x += self.xShift
y += self.yShift
if self.line is not None:
for obj in self.line:
graphicsUtils.remove_from_screen(obj)
self.line = []
prevPoint = self.to_screen((x[0], y[0]))
for i in xrange(1, len(x)):
point = self.to_screen((x[i], y[i]))
self.line.append(graphicsUtils.line(prevPoint, point, LINE_COLOR))
prevPoint = point
# prevPoint = self.to_screen((x[0],y[0]))
# for i in xrange(1,len(x)):
# point = self.to_screen((x[i],y[i]))
# line.append(graphicsUtils.line(prevPoint, point, LINE_COLOR, filled=0, behind=0)
#
# prevPoint = point
if self.addPacmanToLineStart is True and len(self.agentImages) > 0:
# Bring pacman to front of display
graphicsUtils._canvas.tag_raise(self.agentImages[0][1][0])
# Put pacman at beginning of line
if w >= 0:
self.movePacman((x[0] - 0.5, y[0]), Directions.EAST,
self.agentImages[0][1])
else:
self.movePacman((x[-1] + 0.5, y[-1]), Directions.WEST,
self.agentImages[0][1])
graphicsUtils.refresh()
graphicsUtils.sleep(1)
def train( self, trainingData, trainingLabels, validationData, validationLabels, showPlot=True, showPacmanPlot=True):
"""
Stochastic gradient descent to learn self.weights
"""
numDimensions = trainingData[0].size
# Initializes weights to zero
self.weights = np.zeros(numDimensions)
if showPlot:
# Initialize list to store loss per iteration for plotting later
trainingLossPerIteration = []
# Initial loss
trainingLoss = self.classificationLoss(trainingData, trainingLabels)
trainingLossPerIteration.append(trainingLoss)
# Check for offset term
plotDims = numDimensions-1
for datum in trainingData:
if datum[-1] != 1:
plotDims += 1
break
if showPacmanPlot and plotDims <=2:
if plotDims == 2:
pacmanDisplay = pacmanPlot.PacmanPlotClassification2D();
pacmanDisplay.plot(trainingData[:,:plotDims], trainingLabels)
else:
pacmanDisplay = pacmanPlot.PacmanPlotLogisticRegression1D();
pacmanDisplay.plot(trainingData[:,0], trainingLabels)
graphicsUtils.sleep(0.1)
# Stochastic gradient descent
for itr in xrange(self.max_iterations):
for (datum, label) in zip(trainingData, trainingLabels):
self.weights = stochasticGradientDescentUpdate(datum, label, self.weights, self.alpha, self.der_loss_dw)
if showPlot:
predictions = self.classify(validationData)
accuracyCount = [predictions[i] == validationLabels[i] for i in range(len(validationLabels))].count(True)
print "Performance on validation set for iteration= %d: (%.1f%%)" % (itr, 100.0*accuracyCount/len(validationLabels))
trainingLoss = self.classificationLoss(trainingData, trainingLabels)
trainingLossPerIteration.append(trainingLoss)
if plotDims <= 2:
if showPacmanPlot:
pacmanDisplay.setWeights(self.weights)
graphicsUtils.sleep(0.1)
else:
if plotDims == 2:
plotUtil.plotClassification2D(trainingData[:,:plotDims],trainingLabels, self.weights, 1)
else:
plotUtil.plotLogisticRegression1D(trainingData[:,:plotDims],trainingLabels, self.weights, 1)
plotUtil.plotCurve(range(len(trainingLossPerIteration)), trainingLossPerIteration, 2, "Training Loss")
if showPlot and showPacmanPlot:
graphicsUtils.end_graphics()
def train( self, trainingData, trainingLabels, validationData, validationLabels, showPlot=True, showPacmanPlot=True):
"""
Stochastic gradient descent to learn self.weights
"""
numDimensions = trainingData[0].size
# Initializes weights to zero
self.weights = np.zeros(numDimensions)
if showPlot:
# Initialize list to store loss per iteration for plotting later
trainingLossPerIteration = []
# Initial loss
trainingLoss = self.classificationLoss(trainingData, trainingLabels)
trainingLossPerIteration.append(trainingLoss)
# Check for offset term
plotDims = numDimensions-1
for datum in trainingData:
if datum[-1] != 1:
plotDims += 1
break
if showPacmanPlot and plotDims <=2:
if plotDims == 2:
pacmanDisplay = pacmanPlot.PacmanPlotClassification2D();
pacmanDisplay.plot(trainingData[:,:plotDims], trainingLabels)
else:
pacmanDisplay = pacmanPlot.PacmanPlotLogisticRegression1D();
pacmanDisplay.plot(trainingData[:,0], trainingLabels)
graphicsUtils.sleep(0.1)
# Stochastic gradient descent
for itr in xrange(self.max_iterations):
for (datum, label) in zip(trainingData, trainingLabels):
self.weights = stochasticGradientDescentUpdate(datum, label, self.weights, self.alpha, self.der_loss_dw)
if showPlot:
predictions = self.classify(validationData)
accuracyCount = [predictions[i] == validationLabels[i] for i in range(len(validationLabels))].count(True)
print "Performance on validation set for iteration= %d: (%.1f%%)" % (itr, 100.0*accuracyCount/len(validationLabels))
trainingLoss = self.classificationLoss(trainingData, trainingLabels)
trainingLossPerIteration.append(trainingLoss)
if plotDims <= 2:
if showPacmanPlot:
pacmanDisplay.setWeights(self.weights)
graphicsUtils.sleep(0.1)
else:
if plotDims == 2:
plotUtil.plotClassification2D(trainingData[:,:plotDims],trainingLabels, self.weights, 1)
else:
plotUtil.plotLogisticRegression1D(trainingData[:,:plotDims],trainingLabels, self.weights, 1)
plotUtil.plotCurve(range(len(trainingLossPerIteration)), trainingLossPerIteration, 2, "Training Loss")
if showPlot and showPacmanPlot:
graphicsUtils.end_graphics()
def plot(self, x, y, weights=None, title='Linear Regression'):
"""
Plot the input values x with their corresponding output values y (either true or predicted).
Also, plot the linear regression line if weights are given; assuming h_w(x) = weights[0]*x + weights[1].
This will draw on the existing pacman window (clearing it first) or create a new one if no window exists.
x: array or list of N scalar values.
y: array or list of N scalar values.
weights: array or list of 2 values (or if just one value, the bias weight is assumed to be zero). If None,
no line is drawn. Default: None
"""
if np.array(x).size == 0:
return
if isinstance(x[0], np.ndarray):
# Scrape the first element of each data point
x = [data[0] for data in x]
xmin = int(math.floor(min(x)))
ymin = int(math.floor(min(y)))
xmax = int(math.ceil(max(x)))
ymax = int(math.ceil(max(y)))
width = xmax - xmin + 3
height = ymax - ymin + 3
self.initPlot(xmin, ymin, width, height)
gameState = self.blankGameState.deepCopy()
gameState.agentStates = []
# Put pacman in bottom left
if self.addPacmanToLineStart is True:
gameState.agentStates.append(
AgentState(Configuration((1, 1), Directions.STOP), True))
# Add ghost at each point
for (px, py) in zip(x, y):
point = (px + self.xShift, py + self.yShift)
gameState.agentStates.append(
AgentState(Configuration(point, Directions.STOP), False))
# self.initialize(gameState)
graphicsUtils.clear_screen()
self.infoPane = InfoPane(gameState.layout, self.gridSize)
self.drawStaticObjects(gameState)
self.drawAgentObjects(gameState)
graphicsUtils.changeText(self.infoPane.scoreText, title)
graphicsUtils.refresh()
graphicsUtils.sleep(1)
if weights is not None:
self.setWeights(weights)
def graphicsSleep(timeToSleep):
graphicsUtils.sleep(timeToSleep)
#time.sleep(timeToSleep)
'''for _ in range(int(timeToSleep / 0.005)):
#print 'attempt sleep'
Display._acquireLock()
#print 'sleep'
graphicsUtils.sleep(0.001)
Display._releaseLock()
time.sleep(0.004)'''
#graphicsUtils.sleep(timeToSleep)
#time.sleep(timeToSleep)
'''startWait = time.time()
def trainGradient(self,
trainingData,
regressionData,
numIterations,
showPlot=True,
showPacmanPlot=True):
print 'Training with gradient ...'
if showPlot:
# Initialize list to store loss per iteration for plotting later
trainingLossPerIteration = []
if showPacmanPlot:
pacmanDisplay = pacmanPlot.PacmanPlotRegression()
pacmanDisplay.plot(trainingData, regressionData)
graphicsUtils.sleep(0.1)
# Initializes weights to zero
numDimensions = trainingData[0].size
self.weights = np.zeros(numDimensions)
# Stochastic gradient descent
for i in xrange(numIterations):
if i + 1 % 10 == 0:
print "Iteration " + str(i + 1) + " of " + str(numIterations)
for (datum, label) in zip(trainingData, regressionData):
self.weights = stochasticGradientDescentUpdate(
datum, label, self.weights, self.alpha, self.der_loss_dw)
if showPlot:
trainingLoss = self.regressionLoss(trainingData,
regressionData)
trainingLossPerIteration.append(trainingLoss)
if showPacmanPlot:
pacmanDisplay.setWeights(self.weights)
graphicsUtils.sleep(0.05)
else:
plotUtil.plotRegression(trainingData, regressionData,
self.weights, 1)
plotUtil.plotCurve(range(len(trainingLossPerIteration)),
trainingLossPerIteration, 2,
"Training Loss")
if showPlot and showPacmanPlot:
graphicsUtils.end_graphics()
def setWeights(self, weights):
"""
Plot the logistic regression line for given weights
This will draw on the existing pacman window with the existing points
weights: array or list of 2 values (or if just one value, the bias weight is assumed to be zero). If None,
no line is drawn. Default: None
"""
weights = np.array(weights)
w1 = weights[0]
w2 = weights[1]
if weights.size >= 3:
b = weights[2]
else:
b = 0
# Line functions
# Line where w1*x1 + w2*x2 + b = 0
# x2 = -(w1*x1 + b)/w2 or
# x1 = -(w2*x2 + b)/w1
# Figure out where line intersections bounding box around points
(point1, point2) = lineBoxIntersection(w1, w2, b, 1 - self.xShift,
1 - self.yShift,
self.width - 2 - self.xShift,
self.height - 2 - self.yShift)
if point1 is not None and point2 is not None:
point1 = (point1[0] + self.xShift, point1[1] + self.yShift)
point2 = (point2[0] + self.xShift, point2[1] + self.yShift)
if self.line is not None:
graphicsUtils.remove_from_screen(self.line)
self.line = graphicsUtils.polygon(
[self.to_screen(point1),
self.to_screen(point2)],
LINE_COLOR,
filled=0,
behind=0)
graphicsUtils.refresh()
graphicsUtils.sleep(1)
def plot(model):
weights = None
if isinstance(model, PerceptronModel):
weights = model.get_param_values()[0][:, 0]
updated = pacmanDisplay.setWeights(weights)
if updated:
graphicsUtils.sleep(0.1)
else:
w1 = model.get_param_values()[0][:, 0][:]
b1 = model.get_param_values()[1][0]
w2 = model.get_param_values()[0][:, 1][:]
b2 = model.get_param_values()[1][1]
w = w1 - w2
b = b1 - b2
weights = np.r_[w, b]
updated = pacmanDisplay.setWeights(weights)
if updated:
graphicsUtils.sleep(0.1)
def initPlot(self, xmin, ymin, width, height):
if graphicsUtils._canvas is not None:
graphicsUtils.clear_screen()
# Initialize GameStateData with blank board with axes
self.width = width
self.height = height
self.xShift = -(xmin - 1)
self.yShift = -(ymin - 1)
self.line = None
self.zoom = min(30.0 / self.width, 20.0 / self.height)
self.gridSize = graphicsDisplay.DEFAULT_GRID_SIZE * self.zoom
# fullRow = ['%']*self.width
# row = ((self.width-1)/2)*[' '] + ['%'] + ((self.width-1)/2)*[' ']
# boardText = ((self.height-1)/2)*[row] + [fullRow] + ((self.height-1)/2)*[row]
numSpaces = self.width - 1
numSpacesLeft = self.xShift
numSpacesRight = numSpaces - numSpacesLeft
numRows = self.height
numRowsBelow = self.yShift
numRowsAbove = numRows - 1 - numRowsBelow
fullRow = ['%'] * self.width
if numSpacesLeft < 0:
row = [' '] * self.width
else:
row = numSpacesLeft * [' '] + ['%'] + numSpacesRight * [' ']
boardText = numRowsAbove * [row] + [fullRow] + numRowsBelow * [row]
layout = Layout(boardText)
self.blankGameState = GameStateData()
self.blankGameState.initialize(layout, 0)
self.initialize(self.blankGameState)
title = 'Pacman Plot'
graphicsUtils.changeText(self.infoPane.scoreText, title)
graphicsUtils.refresh()
graphicsUtils.sleep(1)
def animatePacman(self, pacman, prevPacman, image):
if self.frameTime < 0:
print('Press any key to step forward, "q" to play')
keys = gU.wait_for_keys()
if 'q' in keys:
self.frameTime = 0.1
if self.frameTime > 0.01 or self.frameTime < 0:
fx, fy = self.getPosition(prevPacman)
px, py = self.getPosition(pacman)
frames = 4.0
for i in range(1, int(frames) + 1):
pos = px * i / frames + fx * (frames - i) / frames, \
py * i / frames + fy * (frames - i) / frames
self.movePacman(pos, self.getDirection(pacman), image)
gU.refresh()
gU.sleep(abs(self.frameTime) / frames)
else:
self.movePacman(self.getPosition(pacman),
self.getDirection(pacman), image)
gU.refresh()
def shadeCost(self, layout, constraints, costVector, feasiblePoints, xmin,
ymin, xmax, ymax):
baseColor = [1.0, 0.0, 0.0]
costs = [self.pointCost(costVector, point) for point in feasiblePoints]
minCost = min(costs)
maxCost = max(costs)
costSpan = maxCost - minCost
allFeasiblePoints = self.getFeasibleLayoutPoints(
layout, constraints, xmin, ymin, xmax, ymax)
# The feasible points themselves may have been gridded to infeasible grid points,
# but we want to make sure they are shaded too.
#cornerPoints = [self.cartesianToLayout(xmin, ymin, xmax, ymax, point) for point in feasiblePoints]
cornerPoints = self.getLayoutPointsWithSymbol(layout, ('o', 'P'))
gridPointsToShade = cornerPoints + allFeasiblePoints
for gridPoint in gridPointsToShade:
point = self.layoutToCartesian(xmin, ymin, xmax, ymax, gridPoint)
relativeCost = (self.pointCost(costVector, point) -
minCost) * 1.0 / costSpan
# Whoops our grid points are flipped top-bottom from what to_screen expects
screenPos = self.to_screen(
(gridPoint[0], len(layout) - gridPoint[1] - 1))
cellColor = [
0.25 + 0.5 * relativeCost * channel for channel in baseColor
]
graphicsUtils.square(screenPos,
0.5 * self.gridSize,
color=graphicsUtils.formatColor(*cellColor),
filled=1,
behind=2)
graphicsUtils.refresh()
graphicsUtils.sleep(1)
def trainGradient(self, trainingData, regressionData, numIterations, showPlot=True, showPacmanPlot=True):
print 'Training with gradient ...'
if showPlot:
# Initialize list to store loss per iteration for plotting later
trainingLossPerIteration = []
if showPacmanPlot:
pacmanDisplay = pacmanPlot.PacmanPlotRegression();
pacmanDisplay.plot(trainingData, regressionData)
graphicsUtils.sleep(0.1)
# Initializes weights to zero
numDimensions = trainingData[0].size
self.weights = np.zeros(numDimensions)
# Stochastic gradient descent
for i in xrange(numIterations):
if i+1 % 10 == 0:
print "Iteration " + str(i+1) + " of "+ str(numIterations)
for (datum, label) in zip(trainingData, regressionData):
self.weights = stochasticGradientDescentUpdate(datum, label, self.weights, self.alpha, self.der_loss_dw)
if showPlot:
trainingLoss = self.regressionLoss(trainingData, regressionData)
trainingLossPerIteration.append(trainingLoss)
if showPacmanPlot:
pacmanDisplay.setWeights(self.weights)
graphicsUtils.sleep(0.05)
else:
plotUtil.plotRegression(trainingData,regressionData, self.weights, 1)
plotUtil.plotCurve(range(len(trainingLossPerIteration)), trainingLossPerIteration, 2, "Training Loss")
if showPlot and showPacmanPlot:
graphicsUtils.end_graphics()
def pacman_display_callback(train_data):
training = train_data[0]
trainingLabels = train_data[1]
if training.shape[1] == 2 and trainingLabels.shape[1] == 2:
pacmanDisplay = pacmanPlot.PacmanPlotClassification2D()
# plot points
pacmanDisplay.plot(training, trainingLabels[:, 0])
graphicsUtils.sleep(0.1)
# plot line
def plot(model):
weights = None
if isinstance(model, PerceptronModel):
weights = model.get_param_values()[0][:, 0]
updated = pacmanDisplay.setWeights(weights)
if updated:
graphicsUtils.sleep(0.1)
else:
w1 = model.get_param_values()[0][:, 0][:]
b1 = model.get_param_values()[1][0]
w2 = model.get_param_values()[0][:, 1][:]
b2 = model.get_param_values()[1][1]
w = w1 - w2
b = b1 - b2
weights = np.r_[w, b]
updated = pacmanDisplay.setWeights(weights)
if updated:
graphicsUtils.sleep(0.1)
return plot
else:
def do_nothing(model):
pass
return do_nothing
def __init__(self,
constraints=[],
infeasiblePoints=[],
feasiblePoints=[],
optimalPoint=None,
costVector=None,
zoom=1.0,
frameTime=0.0):
"""
Create and dispaly a pacman plot figure.
This will draw on the existing pacman window (clearing it first) or create a new one if no window exists.
constraints: list of inequality constraints, where each constraint w1*x + w2*y <= b is represented as a tuple ((w1, w2), b)
infeasiblePoints (food): list of points where each point is a tuple (x, y)
feasiblePoints (power): list of points where each point is a tuple (x, y)
optimalPoint (pacman): optimal point as a tuple (x, y)
costVector (shading): cost vector represented as a tuple (c1, c2), where cost is c1*x + c2*x
"""
super(PacmanPlotLP, self).__init__(zoom, frameTime)
xmin = 100000
ymin = 100000
xmax = -100000
ymax = -100000
for point in feasiblePoints:
if point[0] < xmin:
xmin = point[0]
if point[0] > xmax:
xmax = point[0]
if point[1] < ymin:
ymin = point[1]
if point[1] > ymax:
ymax = point[1]
if len(feasiblePoints) == 0:
for point in infeasiblePoints:
if point[0] < xmin:
xmin = point[0]
if point[0] > xmax:
xmax = point[0]
if point[1] < ymin:
ymin = point[1]
if point[1] > ymax:
ymax = point[1]
xmin = int(math.floor(xmin)) - 3
ymin = int(math.floor(ymin)) - 3
xmax = int(math.ceil(xmax)) + 3
ymax = int(math.ceil(ymax)) + 3
width = xmax - xmin + 1
height = ymax - ymin + 1
# p = feasiblePoints[2]
# print("p={}".format(p))
# print("feasible={}".format(self.pointFeasible(p, constraints)))
# g = self.cartesianToLayout(xmin, ymin, xmax, ymax, p)
# print("g={}".format(g))
# gr = (int(round(g[0])), int(round(g[1])))
# p2 = self.layoutToCartesian(xmin, ymin, xmax, ymax, gr)
# print("p2={}".format(p2))
# print("p2 feasible={}".format(self.pointFeasible(p2, constraints)))
layoutLists = self.blankLayoutLists(width, height)
self.addInfeasibleGhosts(layoutLists, constraints, xmin, ymin, xmax,
ymax)
layoutLists = self.changeBorderGhostsToWall(layoutLists)
for point in infeasiblePoints:
self.addCartesianPointToLayout(layoutLists, point, '.', xmin, ymin,
xmax, ymax)
for point in feasiblePoints:
self.addCartesianPointToLayout(layoutLists, point, 'o', xmin, ymin,
xmax, ymax)
if optimalPoint is not None:
self.addCartesianPointToLayout(layoutLists, optimalPoint, 'P',
xmin, ymin, xmax, ymax)
if graphicsUtils._canvas is not None:
graphicsUtils.clear_screen()
# Initialize GameStateData with blank board with axes
self.width = width
self.height = height
self.zoom = min(30.0 / self.width, 20.0 / self.height)
self.gridSize = graphicsDisplay.DEFAULT_GRID_SIZE * self.zoom
maxNumGhosts = 10000
layout = Layout(layoutLists)
self.blankGameState = GameStateData()
self.blankGameState.initialize(layout, maxNumGhosts)
self.initialize(self.blankGameState)
title = 'Pacman Plot LP'
graphicsUtils.changeText(self.infoPane.scoreText, title)
graphicsUtils.refresh()
graphicsUtils.sleep(1)
if costVector is not None:
self.shadeCost(layoutLists, constraints, costVector,
feasiblePoints, xmin, ymin, xmax, ymax)
def runRegressor(args, options):
regressor = args['regressor']
# Load data
numIter = options.iterations
if(options.data!="BerkeleyHousing"):
print "Loading simple dataset: " + options.data + " ..."
data = np.load(options.data + ".npz")
regressor.setLearningRate(0.01)
trainingData = data["data"]
trainingRegressionResult = data["regressionResults"]
validationData = data["dataVali"]
validationRegressionResult = data["regressionResultsVali"]
testingData = data["dataTest"]
testingRegressionResult = data["regressionResultsTest"]
paras = data["paras"]
else:
print "Loading Berkeley housing dataset ..."
regressor.setLearningRate(0.00000001)
data = np.load("BerkeleyHousing.npz")
# dataTest = np.load("berkeleyHousingTest.npz")
trainingData = data["data"]
trainingRegressionResult = data["regressionResults"]
validationData = []
validationRegressionResult = []
testingData = data["dataTest"]
testingRegressionResult = data["regressionResults"]
# Append 1 to all data points to allow for a bias offset (and convert to Nx2 matrix)
trainingData = np.hstack((trainingData[:,None], np.ones( (trainingData.size,1) )))
if options.data!="BerkeleyHousing":
validationData = np.hstack((validationData[:,None], np.ones( (validationData.size,1) )))
testingData = np.hstack((testingData[:,None], np.ones( (testingData.size,1) )))
# Conduct training and testing
print "Training..."
if(options.method == "analytical"):
regressor.trainAnalytical(trainingData, trainingRegressionResult)
else:
regressor.trainGradient(trainingData, trainingRegressionResult, numIter, options.Print)
if options.Print:
if options.ghosts:
pacmanDisplay = pacmanPlot.PacmanPlotRegression();
pacmanDisplay.plot(trainingData, trainingRegressionResult, regressor.weights, title='Training: Linear Regression')
graphicsUtils.sleep(3)
else:
plotUtil.plotRegression(trainingData,trainingRegressionResult, regressor.weights,1,True,False,'Training: Linear Regression')
if len(validationData) > 0:
print "Validating..."
if options.Print:
if options.ghosts:
pacmanDisplay = pacmanPlot.PacmanPlotRegression();
pacmanDisplay.plot(validationData, validationRegressionResult, regressor.weights, title='Validating: Linear Regression')
graphicsUtils.sleep(3)
else:
plotUtil.plotRegression(validationData,validationRegressionResult, regressor.weights,1,True,False, 'Validating: Linear Regression')
validationLoss = regressor.regressionLoss(validationData, validationRegressionResult)
print "Validation loss: " + str(validationLoss)
else:
print "No validation data provided"
print "Testing..."
if options.Print:
if options.ghosts:
pacmanDisplay = pacmanPlot.PacmanPlotRegression();
pacmanDisplay.plot(testingData, testingRegressionResult, regressor.weights, title='Testing: Linear Regression')
graphicsUtils.sleep(3)
else:
plotUtil.plotRegression(testingData, testingRegressionResult, regressor.weights,1,True,False, 'Testing: Linear Regression')
testingLoss = regressor.regressionLoss(testingData, testingRegressionResult)
print "Testing loss: " + str(testingLoss)
if options.Print:
if options.ghosts:
# pacmanDisplay.takeControl()
graphicsUtils.end_graphics()
def plot(self, x, y, weights=None, title='Logistic Regression'):
"""
Plot the 1D input points, data[i], colored based on their corresponding labels (either true or predicted).
Also, plot the logistic function fit if weights are given.
This will draw on the existing pacman window (clearing it first) or create a new one if no window exists.
x: list of 1D points, where each 1D point in the list is a 1 element numpy.ndarray
y: list of N labels, one for each point in data. Labels can be of any type that can be converted
a string.
weights: array of 2 values the first one is the weight on the data and the second value is the bias weight term.
If there are only 1 values in weights,
the bias term is assumed to be zero. If None, no line is drawn. Default: None
"""
if np.array(x).size == 0:
return
# Process data, sorting by label
possibleLabels = list(set(y))
sortedX = {}
for label in possibleLabels:
sortedX[label] = []
for i in range(len(x)):
sortedX[y[i]].append(x[i])
xmin = int(math.floor(min(x)))
xmax = int(math.ceil(max(x)))
ymin = int(math.floor(0)) - 1
ymax = int(math.ceil(1))
width = xmax - xmin + 3
height = ymax - ymin + 3
self.initPlot(xmin, ymin, width, height)
gameState = self.blankGameState.deepCopy()
gameState.agentStates = []
# Put pacman in bottom left
if self.addPacmanToLineStart is True:
gameState.agentStates.append(
AgentState(Configuration((1, 1), Directions.STOP), True))
# Add ghost at each point
for (py, label) in enumerate(possibleLabels):
pointsX = sortedX[label]
for px in pointsX:
point = (px + self.xShift, py + self.yShift)
agent = AgentState(Configuration(point, Directions.STOP),
False)
agent.isPacman = 1 - py
gameState.agentStates.append(agent)
# self.initialize(gameState)
graphicsUtils.clear_screen()
self.infoPane = InfoPane(gameState.layout, self.gridSize)
self.drawStaticObjects(gameState)
self.drawAgentObjects(gameState)
graphicsUtils.changeText(self.infoPane.scoreText, title)
graphicsUtils.refresh()
graphicsUtils.sleep(1)
if weights is not None:
self.setWeights(weights)
def setWeights(self, weights):
"""
Plot the linear regression line for given weights; assuming h_w(x) = weights[0]*x + weights[1].
This will draw on the existing pacman window with the existing points
weights: array or list of 2 values (or if just one value, the bias weight is assumed to be zero). If None,
no line is drawn. Default: None
"""
weights = np.array(weights)
if weights.size >= 2:
w = weights[0]
b = weights[1]
else:
w = float(weights)
b = 0
# xmin = min(x)
# xmax = max(x)
#
# ymin = w*xmin + b
# ymax = w*xmax + b
#
# point1 = (xmin+self.xShift, ymin+self.yShift)
# point2 = (xmax+self.xShift, ymax+self.yShift)
(point1, point2) = lineBoxIntersection(w, -1, b, 1 - self.xShift,
1 - self.yShift,
self.width - 2 - self.xShift,
self.height - 2 - self.yShift)
if point1 is not None and point2 is not None:
point1 = (point1[0] + self.xShift, point1[1] + self.yShift)
point2 = (point2[0] + self.xShift, point2[1] + self.yShift)
dx = point2[0] - point1[0]
dy = point2[1] - point1[1]
if dx == 0:
angle = 90 + 180 * dy * 1.0 / abs(dy)
else:
angle = math.atan(dy * 1.0 / dx) * 180.0 / math.pi
if self.line is not None:
graphicsUtils.remove_from_screen(self.line)
self.line = graphicsUtils.polygon(
[self.to_screen(point1),
self.to_screen(point2)],
LINE_COLOR,
filled=0,
behind=0)
if self.addPacmanToLineStart is True and len(self.agentImages) > 0:
# Bring pacman to front of display
graphicsUtils._canvas.tag_raise(self.agentImages[0][1][0])
# Put pacman at beginning of line
self.movePacman(point1, angle, self.agentImages[0][1])
graphicsUtils.refresh()
graphicsUtils.sleep(1)
def runRegressor(args, options):
regressor = args['regressor']
# Load data
numIter = options.iterations
if (options.data != "BerkeleyHousing"):
print "Loading simple dataset: " + options.data + " ..."
data = np.load(options.data + ".npz")
regressor.setLearningRate(0.01)
trainingData = data["data"]
trainingRegressionResult = data["regressionResults"]
validationData = data["dataVali"]
validationRegressionResult = data["regressionResultsVali"]
testingData = data["dataTest"]
testingRegressionResult = data["regressionResultsTest"]
paras = data["paras"]
else:
print "Loading Berkeley housing dataset ..."
regressor.setLearningRate(0.00000001)
data = np.load("BerkeleyHousing.npz")
# dataTest = np.load("berkeleyHousingTest.npz")
trainingData = data["data"]
trainingRegressionResult = data["regressionResults"]
validationData = []
validationRegressionResult = []
testingData = data["dataTest"]
testingRegressionResult = data["regressionResults"]
# Append 1 to all data points to allow for a bias offset (and convert to Nx2 matrix)
trainingData = np.hstack(
(trainingData[:, None], np.ones((trainingData.size, 1))))
if options.data != "BerkeleyHousing":
validationData = np.hstack(
(validationData[:, None], np.ones((validationData.size, 1))))
testingData = np.hstack(
(testingData[:, None], np.ones((testingData.size, 1))))
# Conduct training and testing
print "Training..."
if (options.method == "analytical"):
regressor.trainAnalytical(trainingData, trainingRegressionResult)
else:
regressor.trainGradient(trainingData, trainingRegressionResult,
numIter, options.Print)
if options.Print:
if options.ghosts:
pacmanDisplay = pacmanPlot.PacmanPlotRegression()
pacmanDisplay.plot(trainingData,
trainingRegressionResult,
regressor.weights,
title='Training: Linear Regression')
graphicsUtils.sleep(3)
else:
plotUtil.plotRegression(trainingData, trainingRegressionResult,
regressor.weights, 1, True, False,
'Training: Linear Regression')
if len(validationData) > 0:
print "Validating..."
if options.Print:
if options.ghosts:
pacmanDisplay = pacmanPlot.PacmanPlotRegression()
pacmanDisplay.plot(validationData,
validationRegressionResult,
regressor.weights,
title='Validating: Linear Regression')
graphicsUtils.sleep(3)
else:
plotUtil.plotRegression(validationData,
validationRegressionResult,
regressor.weights, 1, True, False,
'Validating: Linear Regression')
validationLoss = regressor.regressionLoss(validationData,
validationRegressionResult)
print "Validation loss: " + str(validationLoss)
else:
print "No validation data provided"
print "Testing..."
if options.Print:
if options.ghosts:
pacmanDisplay = pacmanPlot.PacmanPlotRegression()
pacmanDisplay.plot(testingData,
testingRegressionResult,
regressor.weights,
title='Testing: Linear Regression')
graphicsUtils.sleep(3)
else:
plotUtil.plotRegression(testingData, testingRegressionResult,
regressor.weights, 1, True, False,
'Testing: Linear Regression')
testingLoss = regressor.regressionLoss(testingData,
testingRegressionResult)
print "Testing loss: " + str(testingLoss)
if options.Print:
if options.ghosts:
# pacmanDisplay.takeControl()
graphicsUtils.end_graphics()
def plot(self, x, y, weights=None, title='Linear Classification'):
"""
Plot the 2D input points, data[i], colored based on their corresponding labels (either true or predicted).
Also, plot the linear separator line if weights are given.
This will draw on the existing pacman window (clearing it first) or create a new one if no window exists.
x: list of 2D points, where each 2D point in the list is a 2 element numpy.ndarray
y: list of N labels, one for each point in data. Labels can be of any type that can be converted
a string.
weights: array of 3 values the first two are the weight on the data and the third value is the bias
weight term. If there are only 2 values in weights, the bias term is assumed to be zero. If None,
no line is drawn. Default: None
"""
if np.array(x).size == 0:
return
# Process data, sorting by label
possibleLabels = list(set(y))
sortedX1 = {}
sortedX2 = {}
for label in possibleLabels:
sortedX1[label] = []
sortedX2[label] = []
for i in range(len(x)):
sortedX1[y[i]].append(x[i][0])
sortedX2[y[i]].append(x[i][1])
x1min = float("inf")
x1max = float("-inf")
for x1Values in sortedX1.values():
x1min = min(min(x1Values), x1min)
x1max = max(max(x1Values), x1max)
x2min = float("inf")
x2max = float("-inf")
for x2Values in sortedX2.values():
x2min = min(min(x2Values), x2min)
x2max = max(max(x2Values), x2max)
x1min = int(math.floor(x1min))
x1max = int(math.ceil(x1max))
x2min = int(math.floor(x2min))
x2max = int(math.ceil(x2max))
width = x1max - x1min + 3
height = x2max - x2min + 3
self.initPlot(x1min, x2min, width, height)
gameState = self.blankGameState.deepCopy()
gameState.agentStates = []
# Add ghost/pacman at each point
for (labelIndex, label) in enumerate(possibleLabels):
pointsX1 = sortedX1[label]
pointsX2 = sortedX2[label]
for (px, py) in zip(pointsX1, pointsX2):
point = (px + self.xShift, py + self.yShift)
agent = AgentState(Configuration(point, Directions.STOP),
False)
agent.isPacman = (labelIndex == 0)
if labelIndex == 2:
agent.scaredTimer = 1
gameState.agentStates.append(agent)
# self.initialize(gameState)
graphicsUtils.clear_screen()
self.infoPane = InfoPane(gameState.layout, self.gridSize)
self.drawStaticObjects(gameState)
self.drawAgentObjects(gameState)
graphicsUtils.changeText(self.infoPane.scoreText, title)
graphicsUtils.refresh()
graphicsUtils.sleep(1)
if weights is not None:
self.setWeights(weights)
