def particle_filtering(e, N, HMM):
"""Particle filtering considering two states variables."""
dist = [0.5, 0.5]
# Weight Initialization
w = [0 for _ in range(N)]
# STEP 1
# Propagate one step using transition model given prior state
dist = vector_add(scalar_vector_product(dist[0], HMM.transition_model[0]),
scalar_vector_product(dist[1], HMM.transition_model[1]))
# Assign state according to probability
s = ['A' if probability(dist[0]) else 'B' for _ in range(N)]
w_tot = 0
# Calculate importance weight given evidence e
for i in range(N):
if s[i] == 'A':
# P(U|A)*P(A)
w_i = HMM.sensor_dist(e)[0] * dist[0]
if s[i] == 'B':
# P(U|B)*P(B)
w_i = HMM.sensor_dist(e)[1] * dist[1]
w[i] = w_i
w_tot += w_i
# Normalize all the weights
for i in range(N):
w[i] = w[i] / w_tot
# Limit weights to 4 digits
for i in range(N):
w[i] = float("{0:.4f}".format(w[i]))
# STEP 2
s = weighted_sample_with_replacement(N, s, w)
return s
def forward(HMM, fv, ev):
prediction = vector_add(
scalar_vector_product(fv[0], HMM.transition_model[0]),
scalar_vector_product(fv[1], HMM.transition_model[1]))
sensor_dist = HMM.sensor_dist(ev)
return normalize(element_wise_product(sensor_dist, prediction))
def backward(HMM, b, ev):
sensor_dist = HMM.sensor_dist(ev)
prediction = element_wise_product(sensor_dist, b)
return normalize(
vector_add(
scalar_vector_product(prediction[0], HMM.transition_model[0]),
scalar_vector_product(prediction[1], HMM.transition_model[1])))
def particle_filtering(e, N, HMM):
"""Particle filtering considering two states variables."""
s = []
dist = [0.5, 0.5]
# State Initialization
s = ['A' if probability(dist[0]) else 'B' for i in range(N)]
# Weight Initialization
w = [0 for i in range(N)]
# STEP 1
# Propagate one step using transition model given prior state
dist = vector_add(scalar_vector_product(dist[0], HMM.transition_model[0]),
scalar_vector_product(dist[1], HMM.transition_model[1]))
# Assign state according to probability
s = ['A' if probability(dist[0]) else 'B' for i in range(N)]
w_tot = 0
# Calculate importance weight given evidence e
for i in range(N):
if s[i] == 'A':
# P(U|A)*P(A)
w_i = HMM.sensor_dist(e)[0]*dist[0]
if s[i] == 'B':
# P(U|B)*P(B)
w_i = HMM.sensor_dist(e)[1]*dist[1]
w[i] = w_i
w_tot += w_i
# Normalize all the weights
for i in range(N):
w[i] = w[i]/w_tot
# Limit weights to 4 digits
for i in range(N):
w[i] = float("{0:.4f}".format(w[i]))
# STEP 2
s = weighted_sample_with_replacement(N, s, w)
return s
def particle_filtering(e, N, HMM):
"""Filtragem de partículas considerando duas variáveis de estados."""
s = []
dist = [0.5, 0.5]
# Inicialização do estado
s = ['A' if probability(dist[0]) else 'B' for i in range(N)]
# Inicialização de peso
w = [0 for i in range(N)]
# PASSO 1 - Propagar um passo usando o modelo de transição dado estado anterior
dist = vector_add(scalar_vector_product(dist[0], HMM.transition_model[0]),
scalar_vector_product(dist[1], HMM.transition_model[1]))
# Atribuir o estado de acordo com a probabilidade
s = ['A' if probability(dist[0]) else 'B' for i in range(N)]
w_tot = 0
# Calcular peso de importância dado evidência e
for i in range(N):
if s[i] == 'A':
# P(U|A)*P(A)
w_i = HMM.sensor_dist(e)[0] * dist[0]
if s[i] == 'B':
# P(U|B)*P(B)
w_i = HMM.sensor_dist(e)[1] * dist[1]
w[i] = w_i
w_tot += w_i
# Normalizar todos os pesos
for i in range(N):
w[i] = w[i] / w_tot
# Limite pesos a 4 dígitos
for i in range(N):
w[i] = float("{0:.4f}".format(w[i]))
# STEP 2
s = weighted_sample_with_replacement(s, w, N)
return s
def BackPropagationLearner(dataset, net, learning_rate, epochs):
"""[Figure 18.23] The back-propagation algorithm for multilayer network"""
# Initialise weights
for layer in net:
for node in layer:
node.weights = random_weights(min_value=-0.5,
max_value=0.5,
num_weights=len(node.weights))
examples = dataset.examples
'''
As of now dataset.target gives an int instead of list,
Changing dataset class will have effect on all the learners.
Will be taken care of later
'''
o_nodes = net[-1]
i_nodes = net[0]
o_units = len(o_nodes)
idx_t = dataset.target
idx_i = dataset.inputs
n_layers = len(net)
inputs, targets = init_examples(examples, idx_i, idx_t, o_units)
for epoch in range(epochs):
# Iterate over each example
for e in range(len(examples)):
i_val = inputs[e]
t_val = targets[e]
# Activate input layer
for v, n in zip(i_val, i_nodes):
n.value = v
# Forward pass
for layer in net[1:]:
for node in layer:
inc = [n.value for n in node.inputs]
in_val = dotproduct(inc, node.weights)
node.value = node.activation(in_val)
# Initialize delta
delta = [[] for i in range(n_layers)]
# Compute outer layer delta
# Error for the MSE cost function
err = [t_val[i] - o_nodes[i].value for i in range(o_units)]
# The activation function used is the sigmoid function
delta[-1] = [
sigmoid_derivative(o_nodes[i].value) * err[i]
for i in range(o_units)
]
# Backward pass
h_layers = n_layers - 2
for i in range(h_layers, 0, -1):
layer = net[i]
h_units = len(layer)
nx_layer = net[i + 1]
# weights from each ith layer node to each i + 1th layer node
w = [[node.weights[k] for node in nx_layer]
for k in range(h_units)]
delta[i] = [
sigmoid_derivative(layer[j].value) *
dotproduct(w[j], delta[i + 1]) for j in range(h_units)
]
# Update weights
for i in range(1, n_layers):
layer = net[i]
inc = [node.value for node in net[i - 1]]
units = len(layer)
for j in range(units):
layer[j].weights = vector_add(
layer[j].weights,
scalar_vector_product(learning_rate * delta[i][j],
inc))
return net
def BackPropagationLearner(dataset, net, learning_rate, epoches):
"[Figure 18.23] The back-propagation algorithm for multilayer network"
# Initialise weights
for layer in net:
for node in layer:
node.weights = [random.uniform(-0.5, 0.5)
for i in range(len(node.weights))]
examples = dataset.examples
'''
As of now dataset.target gives an int instead of list,
Changing dataset class will have effect on all the learners.
Will be taken care of later
'''
idx_t = [dataset.target]
idx_i = dataset.inputs
n_layers = len(net)
o_nodes = net[-1]
i_nodes = net[0]
for epoch in range(epoches):
# Iterate over each example
for e in examples:
i_val = [e[i] for i in idx_i]
t_val = [e[i] for i in idx_t]
# Activate input layer
for v, n in zip(i_val, i_nodes):
n.value = v
# Forward pass
for layer in net[1:]:
for node in layer:
inc = [n.value for n in node.inputs]
in_val = dotproduct(inc, node.weights)
node.value = node.activation(in_val)
# Initialize delta
delta = [[] for i in range(n_layers)]
# Compute outer layer delta
o_units = len(o_nodes)
err = [t_val[i] - o_nodes[i].value
for i in range(o_units)]
delta[-1] = [(o_nodes[i].value)*(1 - o_nodes[i].value) *
(err[i]) for i in range(o_units)]
# Backward pass
h_layers = n_layers - 2
for i in range(h_layers, 0, -1):
layer = net[i]
h_units = len(layer)
nx_layer = net[i+1]
# weights from each ith layer node to each i + 1th layer node
w = [[node.weights[k] for node in nx_layer]
for k in range(h_units)]
delta[i] = [(layer[j].value) * (1 - layer[j].value) *
dotproduct(w[j], delta[i+1])
for j in range(h_units)]
# Update weights
for i in range(1, n_layers):
layer = net[i]
inc = [node.value for node in net[i-1]]
units = len(layer)
for j in range(units):
layer[j].weights = vector_add(layer[j].weights,
scalar_vector_product(
learning_rate * delta[i][j], inc))
return net
def BackPropagationLearner(dataset, net, learning_rate, epoches):
"[Figure 18.23] The back-propagation algorithm for multilayer network"
# Initialise weights
for layer in net:
for node in layer:
node.weights = [
random.uniform(-0.5, 0.5) for i in range(len(node.weights))
]
examples = dataset.examples
'''
As of now dataset.target gives an int instead of list,
Changing dataset class will have effect on all the learners.
Will be taken care of later
'''
idx_t = [dataset.target]
idx_i = dataset.inputs
n_layers = len(net)
o_nodes = net[-1]
i_nodes = net[0]
for epoch in range(epoches):
# Iterate over each example
for e in examples:
i_val = [e[i] for i in idx_i]
t_val = [e[i] for i in idx_t]
# Activate input layer
for v, n in zip(i_val, i_nodes):
n.value = v
# Forward pass
for layer in net[1:]:
for node in layer:
inc = [n.value for n in node.inputs]
in_val = dotproduct(inc, node.weights)
node.value = node.activation(in_val)
# Initialize delta
delta = [[] for i in range(n_layers)]
# Compute outer layer delta
o_units = len(o_nodes)
err = [t_val[i] - o_nodes[i].value for i in range(o_units)]
delta[-1] = [(o_nodes[i].value) * (1 - o_nodes[i].value) * (err[i])
for i in range(o_units)]
# Backward pass
h_layers = n_layers - 2
for i in range(h_layers, 0, -1):
layer = net[i]
h_units = len(layer)
nx_layer = net[i + 1]
# weights from each ith layer node to each i + 1th layer node
w = [[node.weights[k] for node in nx_layer]
for k in range(h_units)]
delta[i] = [(layer[j].value) * (1 - layer[j].value) *
dotproduct(w[j], delta[i + 1])
for j in range(h_units)]
# Update weights
for i in range(1, n_layers):
layer = net[i]
inc = [node.value for node in net[i - 1]]
units = len(layer)
for j in range(units):
layer[j].weights = vector_add(
layer[j].weights,
scalar_vector_product(learning_rate * delta[i][j],
inc))
return net
def backward(HMM, b, ev):
sensor_dist = HMM.sensor_dist(ev)
prediction = element_wise_product(sensor_dist, b)
return(normalize(vector_add(scalar_vector_product(prediction[0], HMM.transition_model[0]),
scalar_vector_product(prediction[1], HMM.transition_model[1]))))
def forward(HMM, fv, ev):
prediction = vector_add(scalar_vector_product(fv[0], HMM.transition_model[0]),
scalar_vector_product(fv[1], HMM.transition_model[1]))
sensor_dist = HMM.sensor_dist(ev)
return(normalize(element_wise_product(sensor_dist, prediction)))
def mul_map(map, turns):
for i in map:
for j in range(turns):
vec = map[i][j]
vec[:] = ut.scalar_vector_product(-1, vec)
def BackPropagationLearner(dataset, net, learning_rate, epochs):
"""[Figure 18.23] The back-propagation algorithm for multilayer network"""
# Initialise weights
for layer in net:
for node in layer:
node.weights = random_weights(min_value=-0.5, max_value=0.5,
num_weights=len(node.weights))
examples = dataset.examples
'''
As of now dataset.target gives an int instead of list,
Changing dataset class will have effect on all the learners.
Will be taken care of later
'''
o_nodes = net[-1]
i_nodes = net[0]
o_units = len(o_nodes)
idx_t = dataset.target
idx_i = dataset.inputs
n_layers = len(net)
inputs, targets = init_examples(examples, idx_i, idx_t, o_units)
for epoch in range(epochs):
# Iterate over each example
for e in range(len(examples)):
i_val = inputs[e]
t_val = targets[e]
# Activate input layer
for v, n in zip(i_val, i_nodes):
n.value = v
# Forward pass
for layer in net[1:]:
for node in layer:
inc = [n.value for n in node.inputs]
in_val = dotproduct(inc, node.weights)
node.value = node.activation(in_val)
# Initialize delta
delta = [[] for i in range(n_layers)]
# Compute outer layer delta
# Error for the MSE cost function
err = [t_val[i] - o_nodes[i].value for i in range(o_units)]
# The activation function used is the sigmoid function
delta[-1] = [sigmoid_derivative(o_nodes[i].value) * err[i] for i in range(o_units)]
# Backward pass
h_layers = n_layers - 2
for i in range(h_layers, 0, -1):
layer = net[i]
h_units = len(layer)
nx_layer = net[i+1]
# weights from each ith layer node to each i + 1th layer node
w = [[node.weights[k] for node in nx_layer] for k in range(h_units)]
delta[i] = [sigmoid_derivative(layer[j].value) * dotproduct(w[j], delta[i+1])
for j in range(h_units)]
# Update weights
for i in range(1, n_layers):
layer = net[i]
inc = [node.value for node in net[i-1]]
units = len(layer)
for j in range(units):
layer[j].weights = vector_add(layer[j].weights,
scalar_vector_product(
learning_rate * delta[i][j], inc))
return net
def BackPropagationLearner(dataset, net, learning_rate, epochs, activation=sigmoid, momentum=False, beta=0.903):
"""[Figure 18.23] The back-propagation algorithm for multilayer networks"""
# Initialise weights
for layer in net:
for node in layer:
node.weights = random_weights(min_value=-0.5, max_value=0.5,
num_weights=len(node.weights))
examples = dataset.examples
'''
As of now dataset.target gives an int instead of list,
Changing dataset class will have effect on all the learners.
Will be taken care of later.
'''
o_nodes = net[-1]
i_nodes = net[0]
o_units = len(o_nodes)
idx_t = dataset.target
idx_i = dataset.inputs
n_layers = len(net)
inputs, targets = init_examples(examples, idx_i, idx_t, o_units)
for epoch in range(epochs):
# Iterate over each example
for e in range(len(examples)):
i_val = inputs[e]
t_val = targets[e]
# Activate input layer
for v, n in zip(i_val, i_nodes):
n.value = v
# Finding the values of the nodes through forward propogation
for layer in net[1:]:
for node in layer:
inc = [n.value for n in node.inputs]
in_val = dotproduct(inc, node.weights)
node.value = node.activation(in_val)
# Initialize delta which stores the values of the gradients for each activation units
delta = [[] for _ in range(n_layers)]
#initializing the velocity_gradient
if momentum == True:
v_dw = [[0 for i in range(len(_))] for _ in net]
# Compute outer layer delta
# Error for the MSE cost function
err = [t_val[i] - o_nodes[i].value for i in range(o_units)]
# The activation function used is relu or sigmoid function
# First backward fast
if node.activation == sigmoid:
delta[-1] = [sigmoid_derivative(o_nodes[i].value) * err[i] for i in range(o_units)]
elif node.activation == relu:
delta[-1] = [relu_derivative(o_nodes[i].value) * err[i] for i in range(o_units)]
elif node.activation == tanh:
delta[-1] = [tanh_derivative(o_nodes[i].value) * err[i] for i in range(o_units)]
elif node.activation == elu:
delta[-1] = [elu_derivative(o_nodes[i].value) * err[i] for i in range(o_units)]
else:
delta[-1] = [leaky_relu_derivative(o_nodes[i].value) * err[i] for i in range(o_units)]
# Propogating backward and finding gradients of nodes for each hidden layer
h_layers = n_layers - 2
for i in range(h_layers, 0, -1):
layer = net[i]
h_units = len(layer)
nx_layer = net[i+1]
# weights from each ith layer node to each i + 1th layer node
w = [[node.weights[k] for node in nx_layer] for k in range(h_units)]
if activation == sigmoid:
delta[i] = [sigmoid_derivative(layer[j].value) * dotproduct(w[j], delta[i+1])
for j in range(h_units)]
elif activation == relu:
delta[i] = [relu_derivative(layer[j].value) * dotproduct(w[j], delta[i+1])
for j in range(h_units)]
elif activation == tanh:
delta[i] = [tanh_derivative(layer[j].value) * dotproduct(w[j], delta[i+1])
for j in range(h_units)]
elif activation == elu:
delta[i] = [elu_derivative(layer[j].value) * dotproduct(w[j], delta[i+1])
for j in range(h_units)]
else:
delta[i] = [leaky_relu_derivative(layer[j].value) * dotproduct(w[j], delta[i+1])
for j in range(h_units)]
#optimization with velocity gradient
t_ = epoch + 1
if momentum == True:
if epoch == 0:
for i in range(len(delta)):
for j in range(len(delta[i])):
v_dw[i][j] = ((1-beta)*delta[i][j])/(1-beta**(t_+1))
else:
for i in range(len(delta)):
for j in range(len(delta[i])):
v_dw[i][j] = (beta*v_dw[i][j]+(1-beta)*delta[i][j])/(1-beta**(t_+1))
# Update weights with normal gradient descent
if momentum == False:
for i in range(1, n_layers):
layer = net[i]
inc = [node.value for node in net[i-1]]
units = len(layer)
for j in range(units):
layer[j].weights = vector_add(layer[j].weights,
scalar_vector_product(
learning_rate * delta[i][j],
inc
))
# Update weights with velocity gradient optimizer in gradient descent
else:
for i in range(1, n_layers):
layer = net[i]
inc = [node.value for node in net[i-1]]
units = len(layer)
for j in range(units):
layer[j].weights = vector_add(layer[j].weights,
scalar_vector_product(
learning_rate * v_dw[i][j],
inc
))
return net
def p_greedy_drone(percepts):
agent_location = percepts['GPS']
agent_heading = percepts['Compass']
# collect communication data
dirts = [o[1] for o in percepts['Objects'] if o[0] == 'Dirt']
drones = [
d[1] for d in percepts['Objects']
if d[0] == 'Drone' and d[1] != agent_location
]
if dirts:
close_dirts = [
d for d in dirts
if distance2(d, agent_location) < (sensor_radius * .75)**2
]
if close_dirts: # if there are dirts close to you, move towards the center (of mass) of them
target = vector_average(close_dirts)
else: # if there are no dirts close to you, move towards the closest dirt
target = find_nearest(agent_location, dirts)
if drones: # if there are drones around, move away from them by half your sensor radius
targets = [target]
for d in [
d for d in drones
if distance2(d, agent_location) < (sensor_radius)**2
]:
targets.append(
vector_add(
scalar_vector_product(
sensor_radius * .5,
vector_add(agent_location,
scalar_vector_product(-1, d))),
agent_location))
target = vector_average(targets)
command = go_to(agent_location, agent_heading, target, bump=False)
return command
elif drones: # if no dirts, but there are drones around
targets = []
for d in [
d for d in drones
if distance2(d, agent_location) < (sensor_radius)**2
]:
targets.append(
vector_add(
scalar_vector_product(
sensor_radius * .5,
vector_add(agent_location,
scalar_vector_product(-1, d))),
agent_location))
if targets:
target = vector_average(targets)
return go_to(agent_location, agent_heading, target, bump=False)
else:
return random.choice([
'TurnRight', 'TurnLeft', 'MoveForward', 'MoveForward',
'MoveForward', 'MoveForward'
])
else: # if no dirts and no drones, make a random action
return random.choice([
'TurnRight', 'TurnLeft', 'MoveForward', 'MoveForward',
'MoveForward', 'MoveForward'
])
def BackPropagationLearner(dataset,
net,
learning_rate,
epochs,
activation=sigmoid):
"""
[Figure 18.23]
The back-propagation algorithm for multilayer networks.
"""
# initialise weights
for layer in net:
for node in layer:
node.weights = random_weights(min_value=-0.5,
max_value=0.5,
num_weights=len(node.weights))
examples = dataset.examples
# As of now dataset.target gives an int instead of list,
# Changing dataset class will have effect on all the learners.
# Will be taken care of later.
o_nodes = net[-1]
i_nodes = net[0]
o_units = len(o_nodes)
idx_t = dataset.target
idx_i = dataset.inputs
n_layers = len(net)
inputs, targets = init_examples(examples, idx_i, idx_t, o_units)
for epoch in range(epochs):
# iterate over each example
for e in range(len(examples)):
i_val = inputs[e]
t_val = targets[e]
# activate input layer
for v, n in zip(i_val, i_nodes):
n.value = v
# forward pass
for layer in net[1:]:
for node in layer:
inc = [n.value for n in node.inputs]
in_val = dot_product(inc, node.weights)
node.value = node.activation(in_val)
# initialize delta
delta = [[] for _ in range(n_layers)]
# compute outer layer delta
# error for the MSE cost function
err = [t_val[i] - o_nodes[i].value for i in range(o_units)]
# calculate delta at output
if node.activation == sigmoid:
delta[-1] = [
sigmoid_derivative(o_nodes[i].value) * err[i]
for i in range(o_units)
]
elif node.activation == relu:
delta[-1] = [
relu_derivative(o_nodes[i].value) * err[i]
for i in range(o_units)
]
elif node.activation == tanh:
delta[-1] = [
tanh_derivative(o_nodes[i].value) * err[i]
for i in range(o_units)
]
elif node.activation == elu:
delta[-1] = [
elu_derivative(o_nodes[i].value) * err[i]
for i in range(o_units)
]
elif node.activation == leaky_relu:
delta[-1] = [
leaky_relu_derivative(o_nodes[i].value) * err[i]
for i in range(o_units)
]
else:
return ValueError("Activation function unknown.")
# backward pass
h_layers = n_layers - 2
for i in range(h_layers, 0, -1):
layer = net[i]
h_units = len(layer)
nx_layer = net[i + 1]
# weights from each ith layer node to each i + 1th layer node
w = [[node.weights[k] for node in nx_layer]
for k in range(h_units)]
if activation == sigmoid:
delta[i] = [
sigmoid_derivative(layer[j].value) *
dot_product(w[j], delta[i + 1]) for j in range(h_units)
]
elif activation == relu:
delta[i] = [
relu_derivative(layer[j].value) *
dot_product(w[j], delta[i + 1]) for j in range(h_units)
]
elif activation == tanh:
delta[i] = [
tanh_derivative(layer[j].value) *
dot_product(w[j], delta[i + 1]) for j in range(h_units)
]
elif activation == elu:
delta[i] = [
elu_derivative(layer[j].value) *
dot_product(w[j], delta[i + 1]) for j in range(h_units)
]
elif activation == leaky_relu:
delta[i] = [
leaky_relu_derivative(layer[j].value) *
dot_product(w[j], delta[i + 1]) for j in range(h_units)
]
else:
return ValueError("Activation function unknown.")
# update weights
for i in range(1, n_layers):
layer = net[i]
inc = [node.value for node in net[i - 1]]
units = len(layer)
for j in range(units):
layer[j].weights = vector_add(
layer[j].weights,
scalar_vector_product(learning_rate * delta[i][j],
inc))
return net
