def Newton_F(Oracle, x0):
##### Initialisation des variables
iter_max = 100
gradient_step = 1
threshold = 0.000001
gradient_norm_list = []
gradient_step_list = []
critere_list = []
time_start = process_time()
x = x0
##### Boucle sur les iterations
for k in range(iter_max):
# Valeur du critere et du gradient
critere, gradient, hessien = Oracle(x, 7)
# Test de convergence
gradient_norm = norm(gradient)
if gradient_norm <= threshold:
break
# Direction de descente
D = -dot(inv(hessien), gradient)
print(gradient_norm)
# Mise a jour des variables
x = x + (gradient_step * D)
# Evolution du gradient, du pas, et du critere
gradient_norm_list.append(gradient_norm)
gradient_step_list.append(gradient_step)
critere_list.append(critere)
##### Resultats de l'optimisation
critere_opt = critere
gradient_opt = gradient
x_opt = x
time_cpu = process_time() - time_start
print()
print('Iteration :', k)
print('Temps CPU :', time_cpu)
print('Critere optimal :', critere_opt)
print('Norme du gradient :', norm(gradient_opt))
# Visualisation de la convergence
Visualg(gradient_norm_list, gradient_step_list, critere_list)
return critere_opt, gradient_opt, x_opt
def get_xy(file_conllu, file_features, file_embedding=None):
mcd = get_mcd()
print("Chargement des arbres")
obj_generateAlltree = ConstructAllTree(file_conllu, mcd, True)
# print(obj_generateAlltree.get_corpus())
# print(obj_generateAlltree.get_vocabulary())
all_tree = obj_generateAlltree.get_allTreeProjectiviser()
# print(all_tree[0].print_tree())
print("Arbres charger : ", len(all_tree))
print("Création du dataset")
features = Features(file_features)
i = 0
for tree in all_tree:
# tree.print_tree()
# if i != 43 and i != 61:
A = Oracle(tree, features)
A.run()
#
# print(features.datas)
#
# print(features.labels_encoders)
print("Convertion du dataset")
print("file_embedding : ", file_embedding)
X, Y = features.get_Data_Set(file_embedding)
labels_encoderX = features.get_label_encoderX()
labels_encoderY = features.get_label_encoderY()
print("X_train_shape", X.shape)
print("Y_train_shape", Y.shape)
return X, Y, labels_encoderX, labels_encoderY, all_tree
def Newton_V(Oracle, x0):
##### Initialisation des variables
iter_max = 100
# gradient_step_ini = 1. # Problème primal.
gradient_step_ini = 1000 # Problème dual.
threshold = 0.000001
error_count = 0 # Compteur de non-convergence de l'algorithme de Fletcher-Lemarechal.
gradient_norm_list = []
gradient_step_list = []
critere_list = []
time_start = process_time()
x = x0
##### Boucle sur les iterations
for k in range(iter_max):
# Valeur du critere et du gradient
critere, gradient, hessien = Oracle(x, 7)
# Test de convergence
gradient_norm = norm(gradient)
if gradient_norm <= threshold:
break
# Direction de descente
direction = -dot(inv(hessien), gradient)
# Pas de descente
gradient_step, error_code = Wolfe(gradient_step_ini, x, direction,
Oracle)
if error_code != 1:
error_count += 1
# Mise a jour des variables
x = x + (gradient_step * direction)
# Evolution du gradient, du pas, et du critere
gradient_norm_list.append(gradient_norm)
gradient_step_list.append(gradient_step)
critere_list.append(critere)
if error_count > 0:
print()
print("Non-convergence de l'algorithme de Fletcher-Lemarechal : {}".
format(error_count))
##### Resultats de l'optimisation
critere_opt = critere
gradient_opt = gradient
x_opt = x
time_cpu = process_time() - time_start
print()
print('Iteration :', k)
print('Temps CPU :', time_cpu)
print('Critere optimal :', critere_opt)
print('Norme du gradient :', norm(gradient_opt))
# Visualisation de la convergence
Visualg(gradient_norm_list, gradient_step_list, critere_list)
return critere_opt, gradient_opt, x_opt,
data_filename=data_dir,
batch_size=batch_size,
sequence_length=sequence_length,
validation_split=validation_split,
fake_batch_size=discriminator_pre_training_fake_batch_size,
seed=seed,
data_type="val",
use_word_vectors=use_word_vectors)
# Initialize Models
oracle = Oracle(train_data_loader=train_dl,
validation_data_loader=val_dl,
units=oracle_hidden_units,
leaky_relu_alpha=oracle_leaky_relu_alpha,
num_layers=oracle_layers,
opt=oracle_optimizer,
dropout_keep_prob=oracle_dropout_keep_prob,
l2_reg_lambda=oracle_l2_regularization_lambda,
sequence_length=sequence_length,
loss=oracle_loss,
metrics=oracle_metrics)
gen = Generator(train_data_loader=train_dl,
validation_data_loader=val_dl,
units=generator_hidden_units,
leaky_relu_alpha=generator_leaky_relu_alpha,
num_layers=generator_layers,
opt=generator_optimizer,
dropout_keep_prob=generator_dropout_keep_prob,
l2_reg_lambda=generator_l2_regularization_lambda,
sequence_length=sequence_length,
loss=generator_loss,
def BFGS(Oracle, x0):
##### Initialisation des variables
iter_max = 10000
# gradient_step_ini = 1. # Problème primal.
gradient_step_ini = 1000. # Problème dual.
threshold = 0.000001
error_count = 0 # Compteur de non-convergence de l'algorithme de Fletcher-Lemarechal.
gradient_norm_list = []
gradient_step_list = []
critere_list = []
time_start = process_time()
x = x0
##### Boucle sur les iterations
for k in range(iter_max):
# Nouvelles valeurs du critere et du gradient
critere, gradient = Oracle(x, 4)
# Test de convergence
gradient_norm = norm(gradient)
if gradient_norm <= threshold:
break
# Direction de descente
if k == 0:
W = np.eye(len(gradient))
else:
delta_x = x - x_p
delta_g = gradient - gradient_p
delta_mat_1 = np.outer(delta_x, delta_g) / np.vdot(
delta_g, delta_x)
delta_mat_2 = np.outer(delta_x, delta_x) / np.vdot(
delta_g, delta_x)
I = np.eye(len(gradient)) # Matrice identité
W = np.dot(np.dot(I - delta_mat_1, W_p),
I - np.transpose(delta_mat_1)) + delta_mat_2
direction = np.dot(-W, gradient)
# Pas de descente
gradient_step, error_code = Wolfe(gradient_step_ini, x, direction,
Oracle)
if error_code != 1:
error_count += 1
# Mise a jour des variables
x_p = x # Valeur précédente de la position
gradient_p = gradient # Valeur précédente du gradient
direction_p = direction # Valeur précédente de la direction
W_p = W
x = x + (gradient_step * direction)
# Evolution du gradient, du pas, et du critere
gradient_norm_list.append(gradient_norm)
gradient_step_list.append(gradient_step)
critere_list.append(critere)
if error_count > 0:
print()
print("Non-convergence de l'algorithme de Fletcher-Lemarechal : {}".
format(error_count))
##### Resultats de l'optimisation
critere_opt = critere
gradient_opt = gradient
x_opt = x
time_cpu = process_time() - time_start
print()
print('Iteration :', k)
print('Temps CPU :', time_cpu)
print('Critere optimal :', critere_opt)
print('Norme du gradient :', norm(gradient_opt))
# Visualisation de la convergence
Visualg(gradient_norm_list, gradient_step_list, critere_list)
return critere_opt, gradient_opt, x_opt,
