def setLocalTransformMatrix(self, m: np.matrix):
'''
Sets the local transform matrix of this bone.
'''
self.transformMatrix = np.matrix(m.copy())
self.markGlobalTransformDirty()
def svd(m: np.matrix):
""" Returns the SVD of a matrix.
Parameters
----------
m: np.matrix
The matrix to decompose
Returns
-------
np.matrix or None
The first matrix of the decomposition. This is a
orthogonal matrix.
np.matrix
The matrix with the singular values in the diagonal.
np.matrix
The second matrix of the decomposition. This one is
also a orthogonal matrix.
"""
m = np.float64(m.copy())
_, columns = m.shape
svdMatrix = m @ m.T
singValues, uMatrix = symmetricEig(svdMatrix)
singValues, uMatrix = _sortEig(singValues, uMatrix)
singValues = np.sqrt(np.abs(singValues))
vMatrix = m.T @ uMatrix
for i in range(vMatrix.shape[1]):
vMatrix[i, :] = vMatrix[i, :] / np.linalg.norm(vMatrix[i, :])
return uMatrix, singValues[:columns], vMatrix.T
def funm(dat: numpy.matrix, f) -> numpy.matrix:
'''Dirty copycat for scipy.linalg.funm'''
ret = dat.copy()
for x in numpy.nditer(ret, op_flags=['readwrite']):
x[...] = f(x)
return ret
def globalToLocalTransformMatrix(self, m: np.matrix) -> np.matrix:
'''
Converts the given global transform into a local transform in respect to this bone's parent.
If this bone has no parent, the given global transform is returned.
'''
if self.parent is None:
return m.copy()
return m @ np.linalg.inv(self.parent.getGlobalTransformMatrix())
def matrix_pow(mat: np.matrix, n: int, mod: int):
# nの2進数表記でビットが立っているところだけ処理すればいい
mattmp = mat.copy()
ret = np.matrix(np.eye(2, dtype='int32')) # 単位元は対角行列
while n > 0:
if n & 1: # ビットが立っているなら処理する
ret *= mattmp
ret %= mod
mattmp = mattmp**2
n >>= 1 # ビットを処理
return ret
def get_next_rnn_matrix(rnn_matrix: np.matrix, distance_matrix: np.matrix,
solution_matrix: np.matrix) -> np.matrix:
global epsilon
matrix = rnn_matrix.copy()
for i in range(matrix.shape[0]):
for j in range(matrix.shape[1]):
epsilon = (np.sum(solution_matrix[:, i]) +
np.sum(solution_matrix[:, j]) - 2)
matrix[i, j] = matrix[i, j] - iter_step * (eta * epsilon) + (
lamda * (distance_matrix[i, j] * np.exp(-current_iter / tau)))
return matrix
def get_matrix_cost(matrix: np.matrix) -> np.matrix:
cost_matrix = matrix.copy()
minimal_column = matrix.min(1)[:np.newaxis]
minimal_column[minimal_column == np.inf] = 0
# Subtract minimal value of a row from matrix
cost_matrix -= minimal_column
minimal_row = cost_matrix.min(0)
minimal_row[minimal_row == np.inf] = 0
# Subtract minimal value of a column from matrix
cost_matrix -= minimal_row
return cost_matrix
def remove_rep_clusts(clusterCords: np.matrix) -> np.matrix:
"""
Remove repeated clusters from a set of clusters.
"""
removedCords = clusterCords.copy()
repIndex = list()
for i in range(removedCords.shape[0]):
if (removedCords[i, :] in np.delete(removedCords, i, axis=0)):
removedCords[i, :] = 0
repIndex.append(i)
removedCords = np.delete(removedCords, repIndex, axis=0)
return removedCords
def calcGlobalTransformMatrix(
self, localTransformMatrix: np.matrix) -> np.matrix:
'''
Calculates the global transform matrix for the local transform given,
without setting the stored global transform of this node.
'''
if self.parent is None:
return localTransformMatrix.copy()
return localTransformMatrix @ self.parent.getGlobalTransformMatrix(
)
def getRandomSurferRanking(connectionMatrix: matrix, decimals=1, beta: float = 0.85, normZeros: bool = False) -> \
Tuple[array, array, int, matrix]:
m = connectionMatrix.copy()
nodeCount: int = m.shape[0]
leapProbability: float = divide(1 - beta, nodeCount)
m = getStochasticMatrix(m, normZeros)
r: matrix = matrix(repeat(divide(1, nodeCount), nodeCount)).transpose()
rZero: array = asarray(r).reshape(-1)
previousR: matrix = zeros(r.shape)
totalIterations: int = 0
while not allclose(previousR, r, rtol=1.e-3, atol=1.e-3):
previousR = r
r = (beta * m * r) + leapProbability
totalIterations += 1
nodeRanking = asarray(r.round(decimals).transpose()).reshape(-1)
return nodeRanking, rZero, totalIterations, m
def get_matrix_cost(matrix: np.matrix, debug=False) -> tuple:
matrix_mod = matrix.copy()
minimal_column = matrix.min(1)[:np.newaxis]
minimal_column[minimal_column == np.inf] = 0
cost = np.sum(minimal_column)
# Subtract minimal value of a row from matrix
matrix_mod -= minimal_column
minimal_row = matrix_mod.min(0)
minimal_row[minimal_row == np.inf] = 0
cost += np.sum(minimal_row)
# Subtract minimal value of a column from matrix
matrix_mod -= minimal_row
if debug:
print(f"Minimal column: {minimal_column}")
print(f"Minimal column cost: {np.sum(minimal_column)}")
print(f"Minimal row: {minimal_row}")
print(f"Minimal row cost: {np.sum(minimal_row)}")
return cost, matrix_mod
def draw_pheromones(self,
pheromone_matrix: np.matrix,
cutoff: float = 0.01,
thickness: float = 1.0,
node_size: float = 1.0,
node_label: bool = False,
label: bool = True):
matrix = pheromone_matrix.copy()
for i, j in np.ndindex(matrix.shape):
if matrix[i, j] < cutoff:
matrix[i, j] = 0
G = nx.from_numpy_matrix(matrix, create_using=nx.DiGraph())
weight = nx.get_edge_attributes(G, 'weight')
node_colors = ["lightblue" for _ in range(matrix.shape[0])]
labels = {k: f"{v:.2f}" for k, v in weight.items()}
if node_label:
node_labels = None
if label:
node_labels = {
k: f"{np.diag(matrix)[k]:.2f}"
for k in range(matrix.shape[0])
}
nx.draw_networkx_labels(G, pos=self.graph_pos, labels=node_labels)
if label:
nx.draw_networkx_edge_labels(G,
self.graph_pos,
edge_labels=labels,
label_pos=0.3)
width = [(w['weight']) * thickness / np.max(matrix)
for u, v, w in G.edges(data=True)]
nx.draw_networkx_nodes(
G,
pos=self.graph_pos,
node_color=node_colors,
node_size=[node_size * 300 * (1 + v) for v in np.diag(matrix)])
nx.draw_networkx_edges(G,
self.graph_pos,
width=width,
alpha=0.3,
connectionstyle='arc3,rad=0.2',
arrowstyle="-|>",
arraowsize=thickness * 3)
def householderQR(m: np.matrix):
""" Returns the matrices of the complete QR decomposition of the matrix.
Parameters
----------
m: np.matrix
The matrix to decompose.
Returns
-------
np.matrix:
The matrix Q of the decomposition. This is an orthonormal matrix.
np.matrix:
The matrix R of the decomposition. This is an upper triangular
matrix.
Raises
------
InvalidMatrixException
If the matrix columns is bigger or equals than the number of rows.
"""
m = np.float64(m.copy())
rows, columns = m.shape
if columns > rows:
raise InvalidMatrixException('Invalid size.')
rMatrix = np.copy(m)
qMatrix = np.eye(rows)
for i in range(columns - (rows == columns)):
hMatrix = np.eye(rows)
xVector = rMatrix[i:, i]
auxVector = xVector / \
(xVector[0] + np.copysign(np.linalg.norm(xVector), xVector[0]))
auxVector[0] = 1
hMatrix[i:, i:] = np.eye(xVector.shape[0])
hMatrix[i:, i:] -= (2 / np.dot(auxVector, auxVector)) * \
np.dot(auxVector[:, None], auxVector[None, :])
qMatrix = qMatrix @ hMatrix
rMatrix = hMatrix @ rMatrix
return qMatrix, rMatrix
def gramSchmidtQR(m: np.matrix):
""" Returns the matrices of the QR decomposition of the matrix.
The columns of the matrix should have all its columns linearly independent.
Parameters
----------
m: np.matrix
The matrix to decompose.
Returns
-------
np.matrix:
The matrix Q of the decomposition. This is an orthonormal matrix.
np.matrix:
The matrix R of the decomposition. This is an upper triangular
matrix.
Raises
------
InvalidMatrixException
If the matrix columns is bigger or equals than the number of rows.
"""
rows, columns = m.shape
if columns > rows:
raise InvalidMatrixException('Invalid size.')
m = np.float64(m.copy())
rMatrix = np.matlib.zeros((columns, columns))
qMatrix = np.matlib.zeros((rows, columns))
for i in range(columns):
aux = m[:, i]
for k in range(i):
rMatrix[k, i] = qMatrix[:, k].T @ m[:, i]
aux = aux - rMatrix[k, i] * qMatrix[:, k]
rMatrix[i, i] = np.linalg.norm(aux)
qMatrix[:, i] = aux / rMatrix[i, i]
return qMatrix, rMatrix
def absorb_to_protein(absorb: numpy.matrix) -> numpy.matrix:
f = _standart_curve()
#FIXME: 调试中先不调用
#ret = funm(absorb, f)
ret = absorb.copy()
return ret
class VectorNeuron(object):
"""
The VectorNeuron class represents a single weight matrix and a corresponding
transfer function.
An input to a VectorNeuron is first multiplied by the weight matrix. The
result is then fed through a transfer function to produce the VectorNeuron's
output.
The output is either the containing neural network's final output or the input
to another VectorNeuron.
"""
__weight_matrix = None
__weight_matrix_backup = None
__bias_vector = None
__delta_w_matrix = None
__result = None
__transfer_function = ""
__mersenne_twister = None
def __init__(self, left_num_neurons, right_num_neurons, transfer_function):
"""
Initializes a vectorneuron with a weight matrix of size (left_num_neurons, right_num_neurons),
a bias vector of size (right_num_neurons, 1), and a transfer function transfer_function.
"""
print '>>> Creating VectorNeuron: (%s, %s) %s' % \
(left_num_neurons, right_num_neurons, transfer_function)
self.__weight_matrix = Matrix(rand(right_num_neurons, left_num_neurons))
self.__weight_matrix_backup = self.__weight_matrix.copy()
self.__bias_vector = Matrix(rand(right_num_neurons, 1))
self.__delta_w_matrix = Matrix(rand(right_num_neurons, left_num_neurons))
self.__mersenne_twister = MersenneTwister()
self.__mersenne_twister.seed(int(1000*time.time()))
self.__transfer_function = transfer_function
def neuron_compute(self, input_matrix):
"""Computes the vectorneuron output for input_matrix"""
self.__result = self.__weight_matrix * input_matrix
current_value = None
transfer_function = self.__transfer_function
row_dim = self.__weight_matrix.shape[0]
input_col_dim = input_matrix.shape[1]
for i in range(0,row_dim):
for j in range(0, input_col_dim):
current_value = self.__result[i, j]
self.__result[i, j]= self.__bias_vector[i, 0] + current_value
cmd = "self.%s(current_value)" % transfer_function
self.__result[i, j] = eval(cmd)
def compute_delta_w(self, m, lr):
"""Computes new delta_w matrix"""
k = 0
delta_w = None
delta_w_row_dim = self.__delta_w_matrix.shape[0]
delta_w_col_dim = self.__delta_w_matrix.shape[1]
for i in range(0, delta_w_row_dim):
for j in range(0,delta_w_col_dim):
k = abs(self.__mersenne_twister.randint(0,math.pow(2,32)) % m)
if k == 0:
delta_w = lr
elif k == 1:
delta_w = -1.0 * lr
else:
delta_w = 0.0
self.__delta_w_matrix[i, j] = delta_w
def compute_delta_w_annealing(self, n, m, lr):
"""Computes new delta_w matrix (annealing style)"""
k = 0
delta_w = None
delta_w_row_dim = self.__delta_w_matrix.shape[0]
for i in range(0,delta_w_row_dim):
delta_w_matrix_col = self.__delta_w_matrix.shape[1]
for j in range(0, delta_w_matrix_col):
k = abs(self.__mersenne_twister.randint(0,math.pow(2,32)) % m)
if k < n:
if k % 2 == 0:
if (k == 0):
delta_w = lr
else:
delta_w = lr / k
elif k % 2 == 1:
delta_w = -1.0 * lr / k
else:
delta_w = 0.0
else:
delta_w = 0.0
self.__delta_w_matrix[i, j] = delta_w
def logsig(self, x):
"""Returns logsig of a single variable x"""
return 1.0/(1.0 + exp(-1.0 * x))
def purelin(self, x):
"""Returns purelin of a single variable x"""
return x
def tansig(self, x):
"""Returns tansig of a single variable x"""
return 2.0/exp(1.0 + exp(-2.0 * x), -1.0)
def linsig(self, x):
"""Returns linsig of a single variable x"""
if x <= 1.0 and x >= -1.0:
return x
if x > 1:
return 1.0
else:
return -1.0
def change_weights(self):
"""Changes weight_matrix by adding delta_w_matrix"""
#print 'weight_matrix orig'
#print self.__weight_matrix
self.__weight_matrix = self.__weight_matrix + self.__delta_w_matrix
#print 'weight matrix new'
#print self.__weight_matrix
def rollback_weights(self):
"""Reset weight_matrix to weight_matrix_backup"""
#print 'resetting weights'
self.__weight_matrix = self.__weight_matrix_backup.copy()
def weight_matrix_backup(self):
"""Copies the current weight_matrix to weight_matrix_backup"""
self.__weight_matrix_backup = self.__weight_matrix.copy()
def get_bias(self):
"""Returns the vectorneuron's bias vector"""
return self.__bias_vector
def get_delta_w(self):
"""Return the computed delta_w matrix used to alter the weights"""
return self.__delta_w_matrix
def get_result(self):
"""Returns the output of vectorneuron's neuron_compute function"""
return self.__result
def get_weight_matrix(self):
"""Returns the vectorneuron's current weight_matrix"""
return self.__weight_matrix
def get_weight_matrix_backup(self):
"""Returns a backup of the vectorneuron's previous weight_matrix"""
return self.__weight_matrix_backup
def get_transfer_function(self):
"""Returns the vectorneuron's transfer function"""
return self.__transfer_function
def write_weight_to_file(self, filename):
"""Write the vectorneuron's weight_matrix to filename """
savetxt(filename, self.__weight_matrix)
return True
def write_bias_to_file(self, filename):
"""Write the vectorneuron's biias vector to filename"""
savetxt(filename, self.__bias_vector)
return True
def simulate_adaptive_control(model: SIR,
initial_run: int,
total_time: int,
lockdown: np.matrix,
migrations: np.matrix,
R_m: Dict[str, float],
beta_v: Dict[str, float],
beta_m: Dict[str, float],
evaluation_period: int = 2 * weeks,
adjacency: Optional[np.matrix] = None) -> SIR:
n = len(model)
model.set_parameters(Rt0 = R_m)\
.run(initial_run, lockdown)
days_run = initial_run
gantt = []
last_category = dict()
while days_run < total_time:
Gs, Ys, Os, Rs = set(), set(), set(), set()
categories = dict(enumerate([Gs, Ys, Os, Rs]))
category_transitions = {}
for (i, unit) in enumerate(model):
latest_Rt = unit.Rt[-1]
if latest_Rt < 1:
Gs.add(i)
beta_cat = 0
else:
if days_run < initial_run + evaluation_period: # force first period to be lockdown
Rs.add(i)
beta_cat = 3
else:
if latest_Rt < 1.5:
Ys.add(i)
beta_cat = 1
elif latest_Rt < 2:
Os.add(i)
beta_cat = 2
else:
Rs.add(i)
beta_cat = 3
if unit.name not in last_category:
last_category[unit.name] = beta_cat
else:
old_beta_cat = last_category[unit.name]
if old_beta_cat != beta_cat:
if beta_cat < old_beta_cat and beta_cat != (
old_beta_cat - 1): # force gradual release
beta_cat = old_beta_cat - 1
if i in categories[old_beta_cat]:
categories[old_beta_cat].remove(i)
categories[beta_cat].add(i)
category_transitions[unit.name] = beta_cat
last_category[unit.name] = beta_cat
gantt.append([unit.name, days_run, beta_cat, max(0, latest_Rt)])
for (unit_name, beta_cat) in category_transitions.items():
unit = model[unit_name]
new_beta = beta_v[unit.name] - (
beta_cat * (beta_v[unit.name] - beta_m[unit.name]) / 3.0)
unit.beta[-1] = new_beta
unit.Rt0 = new_beta * unit.gamma
phased_migration = migrations.copy()
for (i, j) in product(range(n), range(n)):
if i not in Gs or j not in Gs:
phased_migration[i, j] = 0
model.run(evaluation_period, phased_migration)
days_run += evaluation_period
model.gantt = gantt
return model
def dot_graph(self,
pheromones: np.matrix = None,
eps: float = 0.01,
render=False,
normalize_pheromone=True,
show_decision=True,
show_greedy_path=False):
p_no_diag = pheromones.copy()
for u in range(pheromones.shape[0]):
p_no_diag[u, u] = 0
norm = np.max(p_no_diag) if normalize_pheromone else 1
dot = graphviz.Digraph(comment="representation of current world state",
engine="neato")
dot.attr(overlap="scale")
dot.attr(K="1")
dot.attr(maxiter="20000")
dot.attr(start="42")
for i in range(self.adjacency.shape[0]):
if pheromones[i, i] / norm < eps:
dot.node(f"{i}", f"{i}")
else:
dot.node(f"{i}", f"{i}:{pheromones[i,i]/norm:.2f}")
for (i, j), v in np.ndenumerate(self.adjacency):
if v > 0:
label = f"{v}"
color = "black"
if pheromones is not None:
color = f"gray{int(90 - 90 * pheromones[i,j] / norm)}"
if pheromones[i, j] <= eps * np.max(pheromones):
label = ""
else:
label = f"{pheromones[i,j] / norm:.2f}"
dot.edge(f"{i}", f"{j}", label=label, color=color)
for i in range(self.adjacency.shape[0]):
state = []
start = []
goal = []
for agent in self.agents:
if not show_decision:
if agent.state == i:
state.append(agent.graph_str)
if agent.start == i:
start.append(agent.graph_str)
if agent.goal == i:
goal.append(agent.graph_str)
if not show_decision:
if len(state) > 0:
s = f"{';'.join(state)}"
dot.node(f"state{i}", label=s, color="blue", shape="box")
dot.edge(f"state{i}", f"{i}", color="blue")
if len(start) > 0:
s = f"start\n{';'.join(start)}"
dot.node(f"start{i}", label=s, color="green", shape="box")
dot.edge(f"start{i}", f"{i}", color="green")
if len(goal) > 0:
s = f"goal\n{';'.join(goal)}"
dot.node(f"goal{i}", label=s, color="red", shape="box")
dot.edge(f"goal{i}", f"{i}", color="red")
if show_decision:
for agent in self.agents:
dot.node(agent.graph_str,
label=agent.graph_str,
color="blue",
shape="box")
dot.edge(agent.graph_str, f"{agent.state}", color="blue")
next = agent.transition_options()
value_sum = np.sum([
agent.transition_value(agent.state, node, **agent.kwargs)
for node in next
])
if value_sum == 0:
value_sum = 1
for node in next:
value = agent.transition_value(agent.state, node, **
agent.kwargs) / value_sum
dot.edge(agent.graph_str,
f"{node}",
color="orange",
fontcolor="orange",
label=f"{value:.2f}")
if show_greedy_path:
for agent in self.agents:
for i, node in enumerate(agent.greedy_path):
dot.edge(agent.graph_str,
f"{node}",
color="yellow",
label=f"{i}",
fontcolor="yellow")
if render:
dot.render(tempfile.mktemp('.gv'), view=True)
return dot
def simulate_adaptive_control_MHA(model: SIR,
initial_run: int,
total_time: int,
lockdown: np.matrix,
migrations: np.matrix,
R_m: Dict[str, float],
beta_v: Dict[str, float],
beta_m: Dict[str, float],
evaluation_period=2 * weeks):
""" simulates the version of adaptive control suggested by the Indian Ministry of Home Affairs, where the trigger is based on infection count doubling time """
n = len(model)
model.set_parameters(Rt0 = R_m)\
.run(initial_run, lockdown)
days_run = initial_run
gantt = []
last_category = dict()
while days_run < total_time:
Gs, Ys, Os, Rs = set(), set(), set(), set()
categories = dict(enumerate([Gs, Ys, Os, Rs]))
category_transitions = {}
for (i, unit) in enumerate(model):
latest_Rt = unit.Rt[-1]
if days_run < initial_run + evaluation_period: # force first period to MHA
if unit.I[-4] != 0 and unit.I[-1] / unit.I[
-4] > 2: # doubling time trigger
Rs.add(i)
beta_cat = 3
else:
Gs.add(i)
beta_cat = 0
else:
if latest_Rt < 1:
Gs.add(i)
beta_cat = 0
elif latest_Rt < 1.5:
Ys.add(i)
beta_cat = 1
elif latest_Rt < 2:
Os.add(i)
beta_cat = 2
else:
Rs.add(i)
beta_cat = 3
if unit.name not in last_category:
last_category[unit.name] = beta_cat
else:
old_beta_cat = last_category[unit.name]
if old_beta_cat != beta_cat:
if beta_cat < old_beta_cat and beta_cat != (
old_beta_cat - 1): # force gradual release
beta_cat = old_beta_cat - 1
if i in categories[old_beta_cat]:
categories[old_beta_cat].remove(i)
categories[beta_cat].add(i)
category_transitions[unit.name] = beta_cat
last_category[unit.name] = beta_cat
gantt.append([unit.name, days_run, beta_cat, max(0, latest_Rt)])
for (unit_name, beta_cat) in category_transitions.items():
unit = model[unit_name]
new_beta = beta_v[unit.name] - (
beta_cat * (beta_v[unit.name] - beta_m[unit.name]) / 3.0)
unit.beta[-1] = new_beta
unit.Rt0 = new_beta * unit.gamma
phased_migration = migrations.copy()
for (i, j) in product(range(n), range(n)):
if i not in Gs or j not in Gs:
phased_migration[i, j] = 0
model.run(evaluation_period, phased_migration)
days_run += evaluation_period
model.gantt = gantt
return model
class VectorNeuron(object):
"""
The VectorNeuron class represents a single weight matrix and a corresponding
transfer function.
An input to a VectorNeuron is first multiplied by the weight matrix. The
result is then fed through a transfer function to produce the VectorNeuron's
output.
The output is either the containing neural network's final output or the input
to another VectorNeuron.
"""
__weight_matrix = None
__weight_matrix_backup = None
__bias_vector = None
__delta_w_matrix = None
__result = None
__transfer_function = ""
__mersenne_twister = None
def __init__(self, left_num_neurons, right_num_neurons, transfer_function):
"""
Initializes a vectorneuron with a weight matrix of size (left_num_neurons, right_num_neurons),
a bias vector of size (right_num_neurons, 1), and a transfer function transfer_function.
"""
print('>>> Creating VectorNeuron: (%s, %s) %s' %
(left_num_neurons, right_num_neurons, transfer_function))
self.__weight_matrix = Matrix(rand(right_num_neurons,
left_num_neurons))
self.__weight_matrix_backup = self.__weight_matrix.copy()
self.__bias_vector = Matrix(rand(right_num_neurons, 1))
self.__delta_w_matrix = Matrix(
rand(right_num_neurons, left_num_neurons))
self.__mersenne_twister = MersenneTwister()
self.__mersenne_twister.seed(int(1000))
self.__transfer_function = transfer_function
def neuron_compute(self, input_matrix):
"""Computes the vectorneuron output for input_matrix"""
self.__result = self.__weight_matrix * input_matrix
current_value = None
transfer_function = self.__transfer_function
row_dim = self.__weight_matrix.shape[0]
input_col_dim = input_matrix.shape[1]
for i in range(0, row_dim):
for j in range(0, input_col_dim):
current_value = self.__result[i, j]
self.__result[i, j] = self.__bias_vector[i, 0] + current_value
cmd = "self.%s(current_value)" % transfer_function
self.__result[i, j] = eval(cmd)
def compute_delta_w(self, m, lr):
"""Computes new delta_w matrix"""
k = 0
delta_w = None
delta_w_row_dim = self.__delta_w_matrix.shape[0]
delta_w_col_dim = self.__delta_w_matrix.shape[1]
for i in range(0, delta_w_row_dim):
for j in range(0, delta_w_col_dim):
k = abs(
self.__mersenne_twister.randint(0, math.pow(2, 32)) % m)
if k == 0:
delta_w = lr
elif k == 1:
delta_w = -1.0 * lr
else:
delta_w = 0.0
self.__delta_w_matrix[i, j] = delta_w
def compute_delta_w_annealing(self, n, m, lr):
"""Computes new delta_w matrix (annealing style)"""
k = 0
delta_w = None
delta_w_row_dim = self.__delta_w_matrix.shape[0]
for i in range(0, delta_w_row_dim):
delta_w_matrix_col = self.__delta_w_matrix.shape[1]
for j in range(0, delta_w_matrix_col):
k = abs(
self.__mersenne_twister.randint(0, math.pow(2, 32)) % m)
if k < n:
if k % 2 == 0:
if (k == 0):
delta_w = lr
else:
delta_w = lr / k
elif k % 2 == 1:
delta_w = -1.0 * lr / k
else:
delta_w = 0.0
else:
delta_w = 0.0
self.__delta_w_matrix[i, j] = delta_w
def logsig(self, x):
"""Returns logsig of a single variable x"""
return 1.0 / (1.0 + exp(-1.0 * x))
def purelin(self, x):
"""Returns purelin of a single variable x"""
return x
def tansig(self, x):
"""Returns tansig of a single variable x"""
return 2.0 / exp(1.0 + exp(-2.0 * x), -1.0)
def linsig(self, x):
"""Returns linsig of a single variable x"""
if x <= 1.0 and x >= -1.0:
return x
if x > 1:
return 1.0
else:
return -1.0
def change_weights(self):
"""Changes weight_matrix by adding delta_w_matrix"""
#print 'weight_matrix orig'
#print self.__weight_matrix
self.__weight_matrix = self.__weight_matrix + self.__delta_w_matrix
#print 'weight matrix new'
#print self.__weight_matrix
def rollback_weights(self):
"""Reset weight_matrix to weight_matrix_backup"""
#print 'resetting weights'
self.__weight_matrix = self.__weight_matrix_backup.copy()
def weight_matrix_backup(self):
"""Copies the current weight_matrix to weight_matrix_backup"""
self.__weight_matrix_backup = self.__weight_matrix.copy()
def get_bias(self):
"""Returns the vectorneuron's bias vector"""
return self.__bias_vector
def get_delta_w(self):
"""Return the computed delta_w matrix used to alter the weights"""
return self.__delta_w_matrix
def get_result(self):
"""Returns the output of vectorneuron's neuron_compute function"""
return self.__result
def get_weight_matrix(self):
"""Returns the vectorneuron's current weight_matrix"""
return self.__weight_matrix
def get_weight_matrix_backup(self):
"""Returns a backup of the vectorneuron's previous weight_matrix"""
return self.__weight_matrix_backup
def get_transfer_function(self):
"""Returns the vectorneuron's transfer function"""
return self.__transfer_function
def write_weight_to_file(self, filename):
"""Write the vectorneuron's weight_matrix to filename """
savetxt(filename, self.__weight_matrix)
return True
def write_bias_to_file(self, filename):
"""Write the vectorneuron's biias vector to filename"""
savetxt(filename, self.__bias_vector)
return True