User:Ping/Python Perceptron - Revision history

Ping at 05:54, 19 March 2009

2009-03-19T05:54:01Z

← Older revision		Revision as of 22:54, 18 March 2009
Line 24:		Line 24:

	def evaluate(self, inputs):		def evaluate(self, inputs):
	"""Evaluate this Perceptron with the given inputs~~, giving 0 or 1~~.		"""Evaluate this Perceptron with the given inputs to give a float.
	'inputs' should be a list of numbers, and the length of the list		'inputs' should be a list of numbers, and the length of the list
	should equal the 'size' used to construct this Perceptron."""		should equal the 'size' used to construct this Perceptron."""
Line 58:		Line 58:
	class BooleanPerceptron(Perceptron):		class BooleanPerceptron(Perceptron):
	def evaluate(self, inputs):		def evaluate(self, inputs):
	"""~~Just like~~ Perceptron.~~evaluate, but apply~~ a threshold."""		"""Evaluate this Perceptron with the given inputs, giving 0 or 1.
			This just applies a threshold to the result of Perceptron.evaluate."""
	return int(Perceptron.evaluate(self, inputs) >= 0)		return int(Perceptron.evaluate(self, inputs) >= 0)

Ping at 05:52, 19 March 2009

2009-03-19T05:52:28Z

← Older revision		Revision as of 22:52, 18 March 2009
Line 17:		Line 17:
	def __init__(self, size):		def __init__(self, size):
	"""The 'size' parameter sets the number of inputs to this Perceptron."""		"""The 'size' parameter sets the number of inputs to this Perceptron."""
	self.weights = [0.0]*size + [0.0]		self.weights = [0]*size + [0]

	def __repr__(self):		def __repr__(self):
Line 59:		Line 59:
	def evaluate(self, inputs):		def evaluate(self, inputs):
	"""Just like Perceptron.evaluate, but apply a threshold."""		"""Just like Perceptron.evaluate, but apply a threshold."""
	return int(Perceptron.evaluate(self, inputs) > 0)		return int(Perceptron.evaluate(self, inputs) >= 0)

	def train_perceptron(perceptron, training_set,		def train_perceptron(perceptron, training_set,

Ping at 05:49, 19 March 2009

2009-03-19T05:49:29Z

← Older revision		Revision as of 22:49, 18 March 2009
Line 9:		Line 9:
	"""Compute the dot product of the two given lists of numbers."""		"""Compute the dot product of the two given lists of numbers."""
	return sum(input*weight for input, weight in zip(inputs, weights))		return sum(input*weight for input, weight in zip(inputs, weights))

			def mean(numbers):
			"""Compute the mean of a list of numbers."""
			return float(sum(numbers))/len(numbers)

	class Perceptron:		class Perceptron:
Line 16:		Line 20:

	def __repr__(self):		def __repr__(self):
	"""~~Display~~ the internal weights of this Perceptron."""		"""Produce a string showing the internal weights of this Perceptron."""
	return '<%s: %r>' % (self.__class__.__name__, self.weights)		return '<%s: %r>' % (self.__class__.__name__, self.weights)

Line 38:		Line 42:

	def print_all(self, training_set):		def print_all(self, training_set):
	"""~~Show~~ how this Perceptron performs on the given training set."""		"""Display how this Perceptron performs on the given training set."""
	print self		print self
	for inputs, expected_output in training_set:		for inputs, expected_output in training_set:
Line 48:		Line 52:
	def rms_error(self, training_set):		def rms_error(self, training_set):
	"""Compute the root-mean-square error across all the training cases."""		"""Compute the root-mean-square error across all the training cases."""
	~~error~~ = ~~sum(~~(self.evaluate(inputs) - expected_output)**2		sq_errors = [(self.evaluate(inputs) - expected_output)**2
	for inputs, expected_output in training_set)		for inputs, expected_output in training_set]
	return (~~float(error)/len(training_set)~~)**0.5		return mean(sq_errors)**0.5

	class BooleanPerceptron(Perceptron):		class BooleanPerceptron(Perceptron):

Ping at 04:27, 19 March 2009

2009-03-19T04:27:16Z

← Older revision		Revision as of 21:27, 18 March 2009
Line 86:		Line 86:
	train_perceptron(BooleanPerceptron(3), training_set, 0.1, 0, 1, 0)		train_perceptron(BooleanPerceptron(3), training_set, 0.1, 0, 1, 0)

	# Train a floating-point Perceptron to fit a straight line.		# Train a floating-point Perceptron to fit a straight line with slope 2.
	training_set = [		training_set = [
	([1.0], 2.0),		([1.0], 2.0),
	([1.5], 3.0),		([1.5], 3.0),
	([2.0], 4.0),		([2.0], 4.0),
			]
			train_perceptron(Perceptron(1), training_set, 0.1, 1e-9, 0.9999, 1e-6)

			# Train a floating-point Perceptron to fit a straight line with slope -3.
			training_set = [
			([-1.0], 6.0),
			([1.5], -1.5),
			([2.0], -3.0),
	]		]
	train_perceptron(Perceptron(1), training_set, 0.1, 1e-9, 0.9999, 1e-6)		train_perceptron(Perceptron(1), training_set, 0.1, 1e-9, 0.9999, 1e-6)
	</pre>		</pre>

Ping at 04:15, 19 March 2009

2009-03-19T04:15:39Z

← Older revision		Revision as of 21:15, 18 March 2009
Line 1:		Line 1:
	The code below defines two classes: Perceptron (which produces a floating-point output) and BooleanPerceptron (which produces a Boolean output). Internally, a bias input ~~is built-in~~ by appending an extra 1 to the given inputs.		The code below defines two classes: Perceptron (which produces a floating-point output) and BooleanPerceptron (which produces a Boolean output). Internally, the Perceptron builds in a bias input by appending an extra 1 to the given inputs.

	<pre>		<pre>

Ping at 04:15, 19 March 2009

2009-03-19T04:15:02Z

← Older revision		Revision as of 21:15, 18 March 2009
Line 17:		Line 17:
	def __repr__(self):		def __repr__(self):
	"""Display the internal weights of this Perceptron."""		"""Display the internal weights of this Perceptron."""
	~~weights = ', '.join('%.3g' % weight for weight in self.weights)~~		return '<%s: %r>' % (self.__class__.__name__, self.weights)
	return '<%s: [%s]>' % (self.__class__.__name__, weights)

	def evaluate(self, inputs):		def evaluate(self, inputs):
Line 31:		Line 30:
	error = self.evaluate(inputs) - expected_output		error = self.evaluate(inputs) - expected_output
	for i, input in enumerate(inputs + [1]):		for i, input in enumerate(inputs + [1]):
	self.weights[i] -= errorinputrate		self.weights[i] -= inputerrorrate

	def train_all(self, training_set, rate):		def train_all(self, training_set, rate):
Line 39:		Line 38:

	def print_all(self, training_set):		def print_all(self, training_set):
	"""~~Print out what the~~ Perceptron ~~produces for~~ the given training set."""		"""Show how this Perceptron performs on the given training set."""
	print self		print self
	for inputs, expected_output in training_set:		for inputs, expected_output in training_set:
Line 93:		Line 92:
	([2.0], 4.0),		([2.0], 4.0),
	]		]
	train_perceptron(Perceptron(1), training_set, 0.1, 1e-9, 0.9999, 1e-3)		train_perceptron(Perceptron(1), training_set, 0.1, 1e-9, 0.9999, 1e-6)
	</pre>		</pre>

Ping at 04:09, 19 March 2009

2009-03-19T04:09:13Z

← Older revision		Revision as of 21:09, 18 March 2009
Line 1:		Line 1:
	The code below defines two classes: Perceptron (which produces a floating-point output) and BooleanPerceptron (which produces a Boolean output). Internally, a bias input is built-in by appending an extra 1 to the given inputs.		The code below defines two classes: Perceptron (which produces a floating-point output) and BooleanPerceptron (which produces a Boolean output). Internally, a bias input is built-in by appending an extra 1 to the given inputs.

	<pre>#!/usr/bin/env python		<pre>
			#!/usr/bin/env python

	__author__ = 'Ka-Ping Yee <ping@zesty.ca>'		__author__ = 'Ka-Ping Yee <ping@zesty.ca>'
Line 84:		Line 85:
	([0, 0, 0], 1),		([0, 0, 0], 1),
	]		]
	train_perceptron(BooleanPerceptron(3), training_set, 0.1, ~~1e-9~~, 1, 0)		train_perceptron(BooleanPerceptron(3), training_set, 0.1, 0, 1, 0)

	# Train a floating-point Perceptron to fit a straight line.		# Train a floating-point Perceptron to fit a straight line.

Ping at 04:08, 19 March 2009

2009-03-19T04:08:35Z

← Older revision		Revision as of 21:08, 18 March 2009
Line 25:		Line 25:
	return dot_product(self.weights, inputs + [1])		return dot_product(self.weights, inputs + [1])

	def ~~adjust~~(self, inputs, rate):		def train(self, inputs, expected_output, rate):
	"""~~Adjust the weights of~~ this Perceptron for the given ~~inputs, using~~		"""Train this Perceptron for a single test case, using the given
	~~the given~~ learning rate."""		learning rate."""
			error = self.evaluate(inputs) - expected_output
	for i, input in enumerate(inputs + [1]):		for i, input in enumerate(inputs + [1]):
	self.weights[i] += ~~rate~~*input		self.weights[i] -= errorinputrate

	~~def train(self, inputs, expected_output, rate):~~
	~~"""Train this Perceptron for a single test case."""~~
	~~self.adjust(inputs,~~ rate*(expected_output - self.evaluate(inputs)))

	def train_all(self, training_set, rate):		def train_all(self, training_set, rate):
Line 70:		Line 67:
	while rate > minimum_rate:		while rate > minimum_rate:
	perceptron.print_all(training_set)		perceptron.print_all(training_set)
	if perceptron.rms_error(training_set) < error_threshold:		if perceptron.rms_error(training_set) <= error_threshold:
	print 'Success:', perceptron		print 'Success:', perceptron
	break		break
Line 87:		Line 84:
	([0, 0, 0], 1),		([0, 0, 0], 1),
	]		]
	train_perceptron(BooleanPerceptron(3), training_set, 0.1, 1e-9, 0~~.9999, 1e-3~~)		train_perceptron(BooleanPerceptron(3), training_set, 0.1, 1e-9, 1, 0)

	# Train a floating-point Perceptron to fit a straight line.		# Train a floating-point Perceptron to fit a straight line.

Ping at 04:04, 19 March 2009

2009-03-19T04:04:08Z

← Older revision		Revision as of 21:04, 18 March 2009
Line 6:		Line 6:

	def dot_product(inputs, weights):		def dot_product(inputs, weights):
			"""Compute the dot product of the two given lists of numbers."""
	return sum(input*weight for input, weight in zip(inputs, weights))		return sum(input*weight for input, weight in zip(inputs, weights))

Line 26:		Line 27:
	def adjust(self, inputs, rate):		def adjust(self, inputs, rate):
	"""Adjust the weights of this Perceptron for the given inputs, using		"""Adjust the weights of this Perceptron for the given inputs, using
	the given ~~training~~ rate."""		the given learning rate."""
	for i, input in enumerate(inputs + [1]):		for i, input in enumerate(inputs + [1]):
	self.weights[i] += rate*input		self.weights[i] += rate*input
Line 62:		Line 63:
	initial_rate, minimum_rate, damping_factor,		initial_rate, minimum_rate, damping_factor,
	error_threshold):		error_threshold):
			"""Train the given Perceptron repeatedly against all the cases in the
			training set, using the given initial learning rate and multiplying it
			by the damping factor each time. Training stops when the RMS error drops
			below the error threshold or the learning rate reaches the minimum."""
	rate = initial_rate		rate = initial_rate
	while rate > minimum_rate:		while rate > minimum_rate:

Ping at 04:01, 19 March 2009

2009-03-19T04:01:43Z

Show changes