Using Python for Artificial Intelligence

X2(t – 2)	X2( t – 1)	Y2(t)
1	1	1
1	0	0
0	1	0
0	0	0

X2(t – 3)	X2(t – 2)	AND NOT	X1(t – 1)	OR
1	1	0	1	1
1	0	1	1	1
0	1	0	1	1
0	0	0	1	1
1	1	0	0	0
1	0	1	0	1
0	1	0	0	0
0	0	0	0	0

CS 106A Stanford University Chris Gregg PDF of this presentation Using Python for Artificial Intelligence

	from numpy import exp, array, random, dot
	training_set_inputs = array([[0, 0, 1], [1, 1, 1], [1, 0, 1], [0, 1, 1]])
	training_set_outputs = array([[0, 1, 1, 0]]).T
	random.seed(1)
	synaptic_weights = 2 * random.random((3, 1)) - 1
	for iteration in range(10000):
	output = 1 / (1 + exp(-(dot(training_set_inputs, synaptic_weights))))
	synaptic_weights += dot(training_set_inputs.T, (training_set_outputs - output)
	* output * (1 - output))
	print 1 / (1 + exp(-(dot(array([1, 0, 0]), synaptic_weights))))

	from numpy import exp, array, random, dot


	class NeuralNetwork():
	def __init__(self):
	# Seed the random number generator, so it generates the same numbers
	# every time the program runs.
	random.seed(1)

	# We model a single neuron, with 3 input connections and 1 output connection.
	# We assign random weights to a 3 x 1 matrix, with values in the range -1 to 1
	# and mean 0.
	self.synaptic_weights = 2 * random.random((3, 1)) - 1

	# The Sigmoid function, which describes an S shaped curve.
	# We pass the weighted sum of the inputs through this function to
	# normalise them between 0 and 1.
	def __sigmoid(self, x):
	return 1 / (1 + exp(-x))

	# The derivative of the Sigmoid function.
	# This is the gradient of the Sigmoid curve.
	# It indicates how confident we are about the existing weight.
	def __sigmoid_derivative(self, x):
	return x * (1 - x)

	# We train the neural network through a process of trial and error.
	# Adjusting the synaptic weights each time.
	def train(self, training_set_inputs, training_set_outputs, number_of_training_iterations):
	for iteration in range(number_of_training_iterations):
	# Pass the training set through our neural network (a single neuron).
	output = self.think(training_set_inputs)

	# Calculate the error (The difference between the desired output
	# and the predicted output).
	error = training_set_outputs - output

	# Multiply the error by the input and again by the gradient of the Sigmoid curve.
	# This means less confident weights are adjusted more.
	# This means inputs, which are zero, do not cause changes to the weights.
	adjustment = dot(training_set_inputs.T, error * self.__sigmoid_derivative(output))

	# Adjust the weights.
	self.synaptic_weights += adjustment

	# The neural network thinks.
	def think(self, inputs):
	# Pass inputs through our neural network (our single neuron).
	return self.__sigmoid(dot(inputs, self.synaptic_weights))


	if __name__ == "__main__":

	#Intialise a single neuron neural network.
	neural_network = NeuralNetwork()

	print("Random starting synaptic weights: ")
	print(neural_network.synaptic_weights)

	# The training set. We have 4 examples, each consisting of 3 input values
	# and 1 output value.
	training_set_inputs = array([[0, 0, 1], [1, 1, 1], [1, 0, 1], [0, 1, 1]])
	training_set_outputs = array([[0, 1, 1, 0]]).T

	# Train the neural network using a training set.
	# Do it 10,000 times and make small adjustments each time.
	neural_network.train(training_set_inputs, training_set_outputs, 10000)

	print("New synaptic weights after training: ")
	print(neural_network.synaptic_weights)

	# Test the neural network with a new situation.
	print("Considering new situation [1, 0, 0] -> ?: ")
	print(neural_network.think(array([1, 0, 0])))

	Random starting synaptic weights:
	[[-0.16595599]
	[ 0.44064899]
	[-0.99977125]]

	New synaptic weights after training:
	[[ 9.67299303]
	[-0.2078435 ]
	[-4.62963669]]

	Considering new situation [1, 0, 0] -> ?:
	[ 0.99993704]

	import torch
	import torchvision
	import torchvision.transforms as transforms

	transform = transforms.Compose(
	[transforms.ToTensor(),
	transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])

	trainset = torchvision.datasets.CIFAR10(root='./data', train=True,
	download=True, transform=transform)
	trainloader = torch.utils.data.DataLoader(trainset, batch_size=4,
	shuffle=True, num_workers=2)

	testset = torchvision.datasets.CIFAR10(root='./data', train=False,
	download=True, transform=transform)
	testloader = torch.utils.data.DataLoader(testset, batch_size=4,
	shuffle=False, num_workers=2)

	classes = ('plane', 'car', 'bird', 'cat',
	'deer', 'dog', 'frog', 'horse', 'ship', 'truck')

	import matplotlib.pyplot as plt
	import numpy as np

	# functions to show an image


	def imshow(img):
	img = img / 2 + 0.5 # unnormalize
	npimg = img.numpy()
	plt.imshow(np.transpose(npimg, (1, 2, 0)))
	plt.show()


	# get some random training images
	dataiter = iter(trainloader)
	images, labels = dataiter.next()

	# show images
	imshow(torchvision.utils.make_grid(images))
	# print labels
	print(' '.join('%5s' % classes[labels[j]] for j in range(4)))

	import torch.nn as nn
	import torch.nn.functional as F


	class Net(nn.Module):
	def __init__(self):
	super(Net, self).__init__()
	self.conv1 = nn.Conv2d(3, 6, 5)
	self.pool = nn.MaxPool2d(2, 2)
	self.conv2 = nn.Conv2d(6, 16, 5)
	self.fc1 = nn.Linear(16 * 5 * 5, 120)
	self.fc2 = nn.Linear(120, 84)
	self.fc3 = nn.Linear(84, 10)

	def forward(self, x):
	x = self.pool(F.relu(self.conv1(x)))
	x = self.pool(F.relu(self.conv2(x)))
	x = x.view(-1, 16 * 5 * 5)
	x = F.relu(self.fc1(x))
	x = F.relu(self.fc2(x))
	x = self.fc3(x)
	return x


	net = Net()

	import torch.optim as optim

	criterion = nn.CrossEntropyLoss()
	optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)

	for epoch in range(2): # loop over the dataset multiple times

	running_loss = 0.0
	for i, data in enumerate(trainloader, 0):
	# get the inputs; data is a list of [inputs, labels]
	inputs, labels = data

	# zero the parameter gradients
	optimizer.zero_grad()

	# forward + backward + optimize
	outputs = net(inputs)
	loss = criterion(outputs, labels)
	loss.backward()
	optimizer.step()

	# print statistics
	running_loss += loss.item()
	if i % 2000 == 1999: # print every 2000 mini-batches
	print('[%d, %5d] loss: %.3f' %
	(epoch + 1, i + 1, running_loss / 2000))
	running_loss = 0.0

	print('Finished Training')

	dataiter = iter(testloader)
	images, labels = dataiter.next()

	# print images
	imshow(torchvision.utils.make_grid(images))
	print('GroundTruth: ', ' '.join('%5s' % classes[labels[j]] for j in range(4)))

	net = Net()
	net.load_state_dict(torch.load(PATH))

	outputs = net(images)

	_, predicted = torch.max(outputs, 1)

	print('Predicted: ', ' '.join('%5s' % classes[predicted[j]]
	for j in range(4)))

	correct = 0
	total = 0
	with torch.no_grad():
	for data in testloader:
	images, labels = data
	outputs = net(images)
	_, predicted = torch.max(outputs.data, 1)
	total += labels.size(0)
	correct += (predicted == labels).sum().item()

	print('Accuracy of the network on the 10000 test images: %d %%' % (
	100 * correct / total))

	class_correct = list(0. for i in range(10))
	class_total = list(0. for i in range(10))
	with torch.no_grad():
	for data in testloader:
	images, labels = data
	outputs = net(images)
	_, predicted = torch.max(outputs, 1)
	c = (predicted == labels).squeeze()
	for i in range(4):
	label = labels[i]
	class_correct[label] += c[i].item()
	class_total[label] += 1


	for i in range(10):
	print('Accuracy of %5s : %2d %%' % (
	classes[i], 100 * class_correct[i] / class_total[i]))

	GroundTruth: cat ship ship plane
	Predicted: dog ship ship ship
	Accuracy of the network on the 10000 test images: 55 %
	Accuracy of plane : 67 %
	Accuracy of car : 72 %
	Accuracy of bird : 36 %
	Accuracy of cat : 18 %
	Accuracy of deer : 45 %
	Accuracy of dog : 60 %
	Accuracy of frog : 64 %
	Accuracy of horse : 62 %
	Accuracy of ship : 65 %
	Accuracy of truck : 65 %

	GroundTruth: cat ship ship plane
	Predicted: cat ship plane plane
	Accuracy of the network on the
	10000 test images: 61 %
	Accuracy of plane : 66 %
	Accuracy of car : 77 %
	Accuracy of bird : 47 %
	Accuracy of cat : 33 %
	Accuracy of deer : 63 %
	Accuracy of dog : 53 %
	Accuracy of frog : 71 %
	Accuracy of horse : 54 %
	Accuracy of ship : 74 %
	Accuracy of truck : 72 %

	PATH = './cifar_net.pth'
	torch.save(net.state_dict(), PATH)