def generate_song(filename): # Generate data delta = get_delta(filename) delta = map(int, delta) delta, count = get_duration(delta) # Set first chord song = ['1'] # Generate rest of song for datapoint in delta: song.append(get_best_chord(datapoint, song[-randint(1, 4):])) if song[-1].isdigit() and song[-1][-1] == '7' and len(song[-1]) == 2 and randint(0, 10) > 5: song[-1] = song[0] print song[-1] return song, count
def run(S: List, save_file_name: str, c: float = 1, d: int = 1):
logging.basicConfig(filename='run_logs/' + save_file_name + '.log',
format='%(asctime)s - %(message)s',
datefmt='%H:%M:%S',
level=logging.INFO)
logging.info('Entered debug mode.')
distances = utils.calc_euclidean_distances(np.array(S))
delta = utils.get_delta(distances)
t = int(np.ceil(np.log2(1 / delta)))
logging.info('Points:\n{}'.format(str(S)))
# logging.info('Distances:\n{}'.format(str(distances)))
# logging.info('Minimal distance (delta): {}'.format(str(delta)))
logging.info('t: {}'.format(str(t)))
# print(str(arr_scaler(distances)))
logging.info('Building hierarchy.')
h = Hierarchy(S, distances, c, t)
logging.info('Done.')
logging.info('Building LP.')
lp = LinearProgram(h, d, delta, save_file_name)
logging.info('Done.')
logging.info('Solving.')
lp.solve()
logging.info('Done.')
w_hierarchy = []
for var in [var for var in lp.model.variables() if var.name.startswith('z') and var.value() == 1]:
split = var.name.split('_')
i = int(split[1][1:])
j = int(split[2][1:])
while len(w_hierarchy) <= i:
w_hierarchy.append([])
w_hierarchy[i].append(j)
w_hierarchy = [sorted(w) for w in w_hierarchy]
W = [S[w] for w in w_hierarchy[-1]]
logging.info(f"W hierarchy: {w_hierarchy}")
logging.info(f"Recall S: {S}")
S_np = np.array(S)
logging.info(f"W: {W}")
W_np = np.array(W)
if W == S:
print("(W == S)")
return W
def main():
if len(sys.argv) > 1:
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((sys.argv[1], 15975))
restaurants = read_restaurants()
yaw = Value('d')
imu_proc = IMU_Process(yaw)
imu_proc.start()
# Stepper is Red Blue White Yellow from top to bottom (towards knob) Dir = LOW means clockwise
target_angle = Value('d')
stepper_proc = Stepper_Process(target_angle, 15, 18, 23, 25, 200)
stepper_proc.start()
lat, lon = Value('d'), Value('d')
gps_proc = GPS_Process(lat, lon)
gps_proc.start()
print_state = False
while True:
bearing = yaw.value
delta, closest, dist = get_delta(bearing, restaurants,
(lat.value, lon.value))
target_angle.value = delta
if math.floor(time.time() % 2) != print_state:
data = (closest.name, dist, bearing, delta, closest.lat,
closest.lon, lat.value, lon.value)
if len(sys.argv) > 1:
s.send(pickle.dumps(data))
else:
print(
'Closest: {}, Dist: {:.2f}\n\tBearing: {:.0f}, Delta: {:.0f}\n\tClosest: {},{}\n\tLoc: {},{}'
.format(*data))
print_state = not print_state
time.sleep(0.005)
def update_branch(self):
"""Updating a branch in a project.
This function gets project name, the branch we updating, file content and type from the client,
then getting the delta for the new version, saving the delta to a new file in the project folder.
"""
isTxt = False
isPng = False
size = self.clientsock.recv(self.BUFSIZ)
self.clientsock.send("Size Gotten")
proInfo = self.clientsock.recv(self.BUFSIZ)
self.clientsock.send("Info Gotten")
extension = self.clientsock.recv(self.BUFSIZ)
self.clientsock.send("Extension Gotten")
size = int(size)
current_Size = 0
buffer = b""
while current_Size < size:
data = self.clientsock.recv(1024)
if not data:
break
if len(data) + current_Size > size:
data = data[:size - current_Size]
buffer += data
current_Size += len(data)
self.clientsock.send("Content Gotten")
proName = proInfo.split('^')[0]
branchVer = proInfo.split('^')[1]
proPath = self.PATH + "\\Projects" + "\\" + proName + "\\"
filesInDir = os.listdir(proPath)
filesInDir.sort()
if extension == "png":
isPng = True
oldVerContent = ""
for file in filesInDir:
if file.split('.')[0] == branchVer.split('.')[0] + "_1":
with open(proPath + file, 'rb') as branchFile:
oldVerContent = branchFile.read()
if file.split('.')[1] == "txt":
isTxt = True
if file.split('.')[1] == "png":
isPng = True
if isPng == False:
for x in range(2, int(branchVer.split('.')[1]) + 1):
for file in filesInDir:
if file.split(
'.')[0] == branchVer.split('.')[0] + "_" + str(x):
with open(proPath + file, 'rb') as oldBranchFile:
oldVerContent = utils.restore_delta(
oldVerContent, oldBranchFile.read(), isTxt)
if file.split('.')[1] == "txt":
isTxt = True
if file.split('.')[1] == "png":
isPng = True
if extension == "txt":
isTxt = True
if isPng == False:
newBranchContent = utils.get_delta(oldVerContent, str(buffer),
isTxt)
branchVer = branchVer.split('.')[0] + "_" + str(
int(branchVer.split('.')[1]) + 1)
proPath = self.PATH + "\\Projects\\" + proName + "\\" + branchVer + "." + extension
with io.FileIO(proPath, "w") as f:
f.write(newBranchContent)
f.close()
else:
branchVer = branchVer.split('.')[0] + "_" + str(
int(branchVer.split('.')[1]) + 1)
proPath = self.PATH + "\\Projects\\" + proName + "\\" + branchVer + "." + extension
with io.FileIO(proPath, "w") as f:
f.write(buffer)
f.close()
else:
branchVer = branchVer.split('.')[0] + "_" + str(
int(branchVer.split('.')[1]) + 1)
proPath = self.PATH + "\\Projects\\" + proName + "\\" + branchVer + "." + extension
with io.FileIO(proPath, "w") as f:
f.write(buffer)
f.close()
time.sleep(0.1)
def update_project(self):
"""Updating a non-branch version.
This function gets a project name, version, content and file type from the client,
then its getting the delta for the new version,
saving the delta in the project folder and updating the Database (also with sharing).
"""
isPng = False
proName = self.clientsock.recv(self.BUFSIZ)
self.clientsock.send("OK")
size = self.clientsock.recv(self.BUFSIZ)
self.clientsock.send("Size Gotten")
self.c.execute("SELECT * FROM " + self.username + " WHERE name=:data",
{'data': proName})
pro = str(self.c.fetchone())
isSharing = pro.split(',')[2]
isSharing = isSharing.replace(" u'", "").replace("'", "")
sharing = pro.split(',')[3]
sharing = sharing.replace(" u'", "").replace("')", "")
pro = pro.split(',')[1]
pro = pro[1:2]
pro = str(int(pro) + 1)
self.c.execute(
"UPDATE " + self.username + " SET version=? WHERE name=?",
[int(pro), proName])
self.conn.commit()
if isSharing != "NoOne":
self.c.execute(
"UPDATE " + isSharing + " SET version=? WHERE name=?",
[int(pro), proName])
self.conn.commit()
self.c.execute(
"SELECT sharing FROM " + isSharing + " WHERE name=:data",
{'data': proName})
users = str(self.c.fetchall())
users = users.replace("[(u'", "").replace("',)]", "")
if "^" in users:
users = users.split("^")
for user in users:
self.c.execute(
"UPDATE " + user + " SET version=? WHERE name=?",
[int(pro), proName])
self.conn.commit()
if sharing != "NoOne":
if "^" in sharing:
users = sharing.split("^")
for user in users:
self.c.execute(
"UPDATE " + user + " SET version=? WHERE name=?",
[int(pro), proName])
self.conn.commit()
fileInfo = self.clientsock.recv(self.BUFSIZ)
if fileInfo == "png":
isPng = True
if fileInfo == "txt":
isTxt = True
else:
isTxt = False
self.clientsock.send("Info Gotten")
size = int(size)
current_Size = 0
buffer = b""
while current_Size < size:
data = self.clientsock.recv(1024)
if not data:
break
if len(data) + current_Size > size:
data = data[:size - current_Size]
buffer += data
current_Size += len(data)
self.clientsock.send("File Gotten")
proPath = self.PATH + "\\Projects\\" + proName + "\\"
filesInDir = os.listdir(proPath)
filesInDir.sort()
for file in filesInDir:
if file.split('.')[1] == "png":
isPng = True
break
if isPng == False:
oldVerContent = ""
for file in filesInDir:
if file.split('.')[0] == "1":
with open(proPath + file, 'r') as verOneFile:
oldVerContent = verOneFile.read()
for x in range(2, int(pro)):
for file in filesInDir:
if file.split('.')[0] == str(x):
with open(proPath + file, 'r') as verXFile:
oldVerContent = utils.restore_delta(
oldVerContent, verXFile.read(), isTxt)
delta = utils.get_delta(oldVerContent, str(buffer), isTxt)
proPath = self.PATH + "\\Projects\\" + proName + "\\" + pro + "." + fileInfo
with io.FileIO(proPath, "w") as f:
f.write(delta)
f.close()
else:
proPath = self.PATH + "\\Projects\\" + proName + "\\" + pro + "." + fileInfo
with io.FileIO(proPath, "w") as f:
f.write(buffer)
f.close()
time.sleep(0.1)
def generate_planets(theta, stars=stlr, mes_threshold=10):
"""
theta = (lnf0, alpha, beta, fB, gamma)
"""
lnf0, alpha, beta, fB, gamma = theta
planets = pd.DataFrame({'kepid':[], 'koi_prad':[], 'koi_period':[],
'koi_prad_true':[], 'koi_max_mult_ev':[]})
n_skipped = 0
for _, star in stars.iterrows():
if np.isnan(star.radius) or np.isnan(star.mass):
n_skipped += 1
continue
n_planets = poisson(np.exp(lnf0)).rvs()
if n_planets == 0:
continue
try:
star2, flux_ratio = get_companion(theta, star)
except ValueError:
n_skipped += 1
continue
#logging.warning('Skipping {}; cannot simulate binary.'.format(star.kepid))
for i in range(n_planets):
# First, figure out true & observed properties of planet
radius, period = draw_planet(theta)
observed_radius, host_star = diluted_radius(radius, star, star2, flux_ratio)
logging.debug('True: {:.2f}, Observed: {:.2f} ({})'.format(radius,
observed_radius,
flux_ratio))
# Then, is it detected?
# First, geometric:
aor = get_a(period, host_star.mass)
if np.isnan(aor):
raise RuntimeError('aor is nan: P={} M={}'.format(period, host_star.mass))
#print(host_star.mass, aor)
transit_prob = get_pgeom(aor / host_star.radius, 0.) # no ecc.
if np.random.random() > transit_prob:
continue
# Then depth and MES:
depth = get_delta(observed_radius * R_EARTH / star.radius)
tau = get_duration(period, aor, 0.) * 24 # no ecc.
try:
mes = get_mes(star, period, depth, tau)
except ValueError:
n_skipped += 1
#raise RuntimeError('MES is nan! {}, {}, {}'.format(depth, tau))
if mes < mes_threshold:
continue
# Add planet to catalog
planets = planets.append({'kepid':star.kepid,
'koi_prad':observed_radius,
'koi_period':period,
'koi_prad_true':radius,
'koi_max_mult_ev':mes}, ignore_index=True)
print('{} planets generated ({} of {} stars skipped.)'.format(len(planets),
n_skipped, len(stars)))
return planets
def create_model(self):
#==================================================================================================#
with tf.name_scope('inputs'):
self.input_xs_1 = tf.placeholder(tf.float32, [None, self.ds_1],
name='input_xs_1')
self.input_xs_2 = tf.placeholder(tf.float32, [None, self.ds_2],
name='input_xs_2')
self.input_ys_1 = tf.placeholder(tf.int32,
[None, self.class_number],
name='input_ys_1')
self.input_ys_2 = tf.placeholder(tf.int32,
[None, self.class_number],
name='input_ys_2')
#----------------------------------------------------------------------------------#
self.input_xl = tf.placeholder(tf.float32, [None, self.dt],
name='input_xl')
self.input_yl = tf.placeholder(tf.int32, [None, self.class_number],
name='input_yl')
self.input_xu = tf.placeholder(tf.float32, [None, self.dt],
name='input_xu')
self.input_yu = tf.placeholder(tf.int32, [None, self.class_number],
name='input_yu')
#----------------------------------------------------------------------------------#
self.lr_1 = tf.placeholder(tf.float32, [], name='lr_1')
self.lr_2 = tf.placeholder(tf.float32, [], name='lr_2')
self.input_xt = tf.concat([self.input_xl, self.input_xu],
0,
name='input_xt')
self.input_ya = tf.concat(
[self.input_ys_1, self.input_ys_2, self.input_yl],
0,
name='input_xa')
#==================================================================================================#
# set the number of each layer of the source generator
self.h_xs_1 = 512 # 2 layers
self.h_xs_2 = 512
#----------------------------#
# set the number of each layer of the target generator
self.h_xt = 512
#----------------------------#
# set the number of each layer of the domain discriminator
self.h_d_1 = 128
#------------------------------------------#
# set the parameters of generator
self.w_g = {
'w1_xs_1':
tf.Variable(
tf.truncated_normal([self.ds_1, self.h_xs_1], stddev=0.01)),
'b1_xs_1':
tf.Variable(tf.truncated_normal([self.h_xs_1], stddev=0.01)),
'w2_xs_1':
tf.Variable(tf.truncated_normal([self.h_xs_1, self.d],
stddev=0.01)),
'b2_xs_1':
tf.Variable(tf.truncated_normal([self.d], stddev=0.01)),
#-----------------------------------------------------------------#
'w1_xs_2':
tf.Variable(
tf.truncated_normal([self.ds_2, self.h_xs_2], stddev=0.01)),
'b1_xs_2':
tf.Variable(tf.truncated_normal([self.h_xs_2], stddev=0.01)),
'w2_xs_2':
tf.Variable(tf.truncated_normal([self.h_xs_2, self.d],
stddev=0.01)),
'b2_xs_2':
tf.Variable(tf.truncated_normal([self.d], stddev=0.01)),
#-----------------------------------------------------------------#
'w1_xt':
tf.Variable(tf.truncated_normal([self.dt, self.h_xt],
stddev=0.01)),
'w2_xt':
tf.Variable(tf.truncated_normal([self.h_xt, self.d], stddev=0.01)),
'b1_xt':
tf.Variable(tf.truncated_normal([self.h_xt], stddev=0.01)),
'b2_xt':
tf.Variable(tf.truncated_normal([self.d], stddev=0.01)),
}
#-----------------------------#
# set the parameters of the classifier
self.w_f = {
'w_f':
tf.Variable(
tf.truncated_normal([self.d, self.class_number], stddev=0.01)),
#--------------------------------------------------------------------#
'b_f':
tf.Variable(tf.truncated_normal([self.class_number], stddev=0.01)),
}
#-----------------------------#
# set the parameters of the domain discriminator
self.w_d = {
'w1_d':
tf.Variable(tf.truncated_normal([self.d, self.h_d_1],
stddev=0.01)),
'w2_d':
tf.Variable(tf.truncated_normal([self.h_d_1, 2], stddev=0.01)),
#--------------------------------------------------------------------#
'b1_d':
tf.Variable(tf.truncated_normal([self.h_d_1], stddev=0.01)),
'b2_d':
tf.Variable(tf.truncated_normal([2], stddev=0.01))
}
#==================================================================================================#
# build projection network of source domains
self.projection_xs_1 = utils.build_xs_1(self.input_xs_1, self.w_g,
tf.nn.leaky_relu)
self.projection_xs_2 = utils.build_xs_2(self.input_xs_2, self.w_g,
tf.nn.leaky_relu)
# build projection network of target domain
self.projection_xt = utils.build_t(self.input_xt, self.w_g,
tf.nn.leaky_relu)
self.projection_xl = tf.slice(self.projection_xt, [0, 0],
[self.nl, -1])
self.projection_xu = tf.slice(self.projection_xt, [self.nl, 0],
[self.nu, -1])
# connecting all projection data
self.all_data = tf.concat(
[self.projection_xs_1, self.projection_xs_2, self.projection_xt],
0)
#==================================================================================================#
# classification loss L_{G,f,alpha}
self.f_xs_1_logits = utils.build_f(self.projection_xs_1, self.w_f)
self.f_xs_2_logits = utils.build_f(self.projection_xs_2, self.w_f)
self.f_xl_logits = utils.build_f(self.projection_xl, self.w_f)
self.f_xu_logits = utils.build_f(self.projection_xu, self.w_f)
self.f_xa_logits = tf.concat(
[self.f_xs_1_logits, self.f_xs_2_logits, self.f_xl_logits], 0)
#------------------------------------------------#
# the accuracy of xs_1
self.pred_xs_1 = tf.nn.softmax(self.f_xs_1_logits)
self.correct_pred_xs_1 = tf.equal(tf.argmax(self.input_ys_1, 1),
tf.argmax(self.pred_xs_1, 1))
self.xs_1_acc = tf.reduce_mean(
tf.cast(self.correct_pred_xs_1, tf.float32))
# the accuracy of xs_2
self.pred_xs_2 = tf.nn.softmax(self.f_xs_2_logits)
self.correct_pred_xs_2 = tf.equal(tf.argmax(self.input_ys_2, 1),
tf.argmax(self.pred_xs_2, 1))
self.xs_2_acc = tf.reduce_mean(
tf.cast(self.correct_pred_xs_2, tf.float32))
# the accuracy of xl
self.pred_xl = tf.nn.softmax(self.f_xl_logits)
self.correct_pred_xl = tf.equal(tf.argmax(self.input_yl, 1),
tf.argmax(self.pred_xl, 1))
self.xl_acc = tf.reduce_mean(tf.cast(self.correct_pred_xl, tf.float32))
# the accuracy of xu
self.pred_yu = tf.nn.softmax(self.f_xu_logits)
self.correct_pred_xu = tf.equal(tf.argmax(self.input_yu, 1),
tf.argmax(self.pred_yu, 1))
self.xu_acc = tf.reduce_mean(tf.cast(self.correct_pred_xu, tf.float32))
#==================================================================================================#
# adversarial loss L_{d,g,alpha}
self.domain_xs_1_logits = utils.build_d(self.projection_xs_1, self.w_d,
tf.nn.relu)
self.domain_xs_2_logits = utils.build_d(self.projection_xs_2, self.w_d,
tf.nn.relu)
self.domain_xt_logits = utils.build_d(self.projection_xt, self.w_d,
tf.nn.relu)
self.domain_xa_logits = tf.concat([
self.domain_xs_1_logits, self.domain_xs_2_logits,
self.domain_xt_logits
], 0)
# the logist of xs_1 of the domain decriminator
self.d_pred_xs_1 = tf.nn.softmax(self.domain_xs_1_logits)
self.d_pred_xs_2 = tf.nn.softmax(self.domain_xs_2_logits)
# the logist of xt of the domain classifier
self.d_pred_xt = tf.nn.softmax(self.domain_xt_logits)
#--------------------------#
self.d_pred_xs_xt = tf.concat(
[self.d_pred_xs_1, self.d_pred_xs_2, self.d_pred_xt], 0)
self.d_pro_xs_xt = tf.reduce_mean(self.d_pred_xs_xt, 0)
#------------------------------------------#
self.xs_1_domain_label = tf.one_hot(tf.ones([self.ns_1], tf.int64), 2)
self.xs_2_domain_label = tf.one_hot(tf.ones([self.ns_2], tf.int64), 2)
self.xt_domain_label = tf.one_hot(tf.zeros([self.nt], tf.int64), 2)
self.domain_ya = tf.concat([
self.xs_1_domain_label, self.xs_2_domain_label,
self.xt_domain_label
], 0)
#-------------------------------------------#
self.xs_1_domain_adv_label = tf.one_hot(
tf.zeros([self.ns_1], tf.int64), 2)
self.xs_2_domain_adv_label = tf.one_hot(
tf.zeros([self.ns_2], tf.int64), 2)
self.xt_domain_adv_label = tf.one_hot(tf.ones([self.nt], tf.int64), 2)
self.domain_adv_ya = tf.concat([
self.xs_1_domain_adv_label, self.xs_2_domain_adv_label,
self.xt_domain_adv_label
], 0)
#==================================================================================================#
# computer the weights of domains
#==================================================================================================#
# compute class centroid matrix
self.class_mean_xs_1, self.class_mean_xs_2, self.class_mean_xt = utils.computer_class_mean(
self.projection_xs_1, self.projection_xs_2, self.projection_xl,
self.projection_xu, self.input_ys_1, self.input_ys_2,
self.input_yl, self.pred_yu, self.class_number)
#------------------------------------------------#
# the weight of domains
self.delta_1, self.delta_2, self.delta_xs_1, self.delta_xs_2 = utils.get_delta(
self.class_mean_xs_1, self.class_mean_xs_2, self.class_mean_xt)
#self.delta_1 = tf.constant(1, tf.float32)
#self.delta_2 = tf.constant(1, tf.float32)
#==================================================================================================#
with tf.name_scope('loss_classifier'):
#self.loss_classifier = loss.get_loss_classifier(self.f_xa_logits, self.input_ya, self.weight_instance)
self.loss_classifier = loss.get_loss_classifier(
self.f_xs_1_logits, self.f_xs_2_logits, self.f_xl_logits,
self.input_ys_1, self.input_ys_2, self.input_yl, self.delta_1,
self.delta_2)
with tf.name_scope('loss_domain'):
self.loss_domain = loss.get_loss_domain(
self.domain_xs_1_logits, self.domain_xs_2_logits,
self.domain_xt_logits, self.xs_1_domain_label,
self.xs_2_domain_label, self.xt_domain_label, self.delta_1,
self.delta_2)
#self.loss_domain = loss.get_loss_domain_square(self.domain_xa_logits, self.domain_ya, self.weight_domain)
with tf.name_scope('loss_domain_adv'):
self.loss_domain_adv = loss.get_loss_domain(
self.domain_xs_1_logits, self.domain_xs_2_logits,
self.domain_xt_logits, self.xs_1_domain_adv_label,
self.xs_2_domain_adv_label, self.xt_domain_adv_label,
self.delta_1, self.delta_2)
#self.loss_domain_adv = loss.get_loss_domain_square(self.domain_xa_logits, self.domain_adv_ya, self.weight_domain)
with tf.name_scope('loss_reg_g'):
self.loss_reg_g = loss.get_loss_reg_g(self.tau, self.w_g, self.w_f)
with tf.name_scope('loss_diff'):
self.loss_diff = tf.reduce_sum(tf.abs(self.w_g['w2_xs_1']-self.w_g['w2_xt'])) \
+ tf.reduce_sum(tf.abs(self.w_g['b2_xs_1']-self.w_g['b2_xt'])) \
+ tf.reduce_sum(tf.abs(self.w_g['w2_xs_2']-self.w_g['w2_xt'])) \
+ tf.reduce_sum(tf.abs(self.w_g['b2_xs_2']-self.w_g['b2_xt']))
#------------------------------------------#
with tf.name_scope('loss_f'):
self.loss_f = self.loss_classifier + self.loss_reg_g
with tf.name_scope('loss_generator'):
self.loss_generator = self.loss_f + self.loss_diff + self.beta * self.loss_domain_adv
with tf.name_scope('loss_discriminator'):
self.loss_discriminator = self.loss_domain
#==================================================================================================#
# train step
self.generator_step = tf.train.AdamOptimizer(self.lr_1).minimize(
self.loss_generator, var_list=[self.w_g, self.w_f])
self.discriminator_step = tf.train.AdamOptimizer(self.lr_2).minimize(
self.loss_discriminator, var_list=[self.w_d])
#==================================================================================================#
#writer = tf.summary.FileWriter("log/", self.sess.graph)
if int((tf.__version__).split('.')[1]) < 12 and int(
(tf.__version__).split('.')[0]) < 1:
init = tf.initialize_all_variables()
else:
init = tf.global_variables_initializer()
self.sess.run(init)
def estimate_change_points(self, D, k):
if self.map_density is None:
self.solution_path()
delta = get_delta(D, k)
return np.array([(np.array(delta.dot(betas)) > 0.04).sum() for betas in self.map_betas])
def backward(self, itr, output_data):
print("--step#%d backward--" % itr)
error = 0
# t_a = self.layer_list[-1].neurons
# t_d = output_data[itr]
#
# if self.loss_function == 'mse':
# error = utils.mse_loss(t_a, t_d)
prev_delta = []
temp_prev_delta = []
for layer in reversed(self.layer_list):
i_current_layer = self.layer_list.index(
layer) # index of current layer
if i_current_layer == 0:
# current layer is the first layer(input layer).
break
prev_layer = self.layer_list[i_current_layer - 1] # previous layer
i_neuron = 0
for neuron in layer.neurons:
if i_current_layer == (len(self.layer_list) - 1):
# for output layer
layer.neurons = utils.convert_not_fired(layer.neurons, 50)
delta = utils.get_delta(i_neuron=i_neuron,
l_connections=[layer.connections],
t_d=output_data[i_neuron],
t_a=neuron,
t_i=prev_layer.neurons,
tau=self.tau,
d=self.delay,
n_terminals=self.n_terminals,
is_output_layer=True,
prev_delta=None)
# if neuron < 0:
# neuron = 40
y, w = utils.get_incoming_connections(
layer.connections, i_neuron)
y = utils.get_y(y, neuron, prev_layer.neurons, self.delay,
self.tau, self.n_terminals)
delta_w = (self.lr * y * delta)
w = w + delta_w # update weights
utils.update_connections(layer.connections, y, w, i_neuron)
temp_prev_delta.append(delta)
i_neuron = i_neuron + 1
else:
# for hidden layer (generalied case)
if i_current_layer == len(self.layer_list):
# first layer --> end point of backwarding
break
next_layer = self.layer_list[i_current_layer +
1] # layer J
delta = utils.get_delta(
i_neuron=i_neuron,
l_connections=[
next_layer.connections, layer.connections
],
t_j=self.layer_list[i_current_layer + 1].neurons,
t_i=neuron,
t_h=self.layer_list[i_current_layer - 1].neurons,
tau=self.tau,
d=self.delay,
n_terminals=self.n_terminals,
is_output_layer=False,
prev_delta=prev_delta)
y, w = utils.get_incoming_connections(
layer.connections, i_neuron)
y = utils.get_y(y, neuron, prev_layer.neurons, self.delay,
self.tau, self.n_terminals)
delta_w = -(self.lr * y * delta)
w = w + delta_w # update weights
utils.update_connections(layer.connections, y, w, i_neuron)
temp_prev_delta.append(delta)
i_neuron = i_neuron + 1
prev_delta.clear()
prev_delta = temp_prev_delta.copy()
temp_prev_delta.clear()
return None