def extract_entropydecrease(patharray,axis = 'no',xaxis = 'blank', yaxis = 'blank',ratio = (4,4),sort = 'no',tight_layout = True,font_size = [20,10]):
plt.rcParams['figure.figsize'] = ratio
plt.xlabel(xaxis, fontsize=font_size[0])
plt.ylabel(yaxis, fontsize=font_size[0])
plt.xticks(fontsize=font_size[1])
plt.yticks(fontsize=font_size[1])
if tight_layout:
plt.tight_layout()
ed = []
for path in patharray:
array = np.array(dr.read_csv(path), dtype=float)
ed.append(array[0])
if axis == 'no':
plt.plot(range(len(ed)), ed)
else:
x = np.array(dr.read_csv(axis), dtype=float)[:,0]
print(x)
x.sort()
print(x)
if sort !='no':
x.sort()
ed.sort()
plt.plot(x, ed)
ax = plt.gca() # 获取当前图像的坐标轴信息
ax.xaxis.get_major_formatter().set_powerlimits((0, 1)) # 将坐标轴的base number设置为一位。
ax.yaxis.get_major_formatter().set_powerlimits((0, 1)) # 将坐标轴的base number设置为一位。
plt.show()
def draw_entropy_bar(patharray,data_address = 'none',xaxis = 'blank', yaxis = 'blank',ratio = (4,4),ylimitaion = (400,500),tight_layout = True, font_size = [20,10]):
plt.rcParams['figure.figsize'] = ratio
plt.xlabel(xaxis, fontsize=font_size[0])
plt.ylabel(yaxis, fontsize=font_size[0])
plt.xticks(fontsize=font_size[1])
plt.yticks(fontsize=font_size[1])
if tight_layout:
plt.tight_layout()
if data_address == 'none':
ed = []
for path in patharray:
array = np.array(dr.read_csv(path), dtype=float)
ed.append(array[0,0])
print(ed)
plt.bar(range(len(ed)), ed)
else:
x = np.array(dr.read_csv(data_address), dtype=float)[:, 0]
plt.bar(range(len(x)),x)
plt.ylim(ylimitaion)
plt.xlabel(xaxis)
plt.ylabel(yaxis)
ax = plt.gca() # 获取当前图像的坐标轴信息
ax.xaxis.get_major_formatter().set_powerlimits((0, 1)) # 将坐标轴的base number设置为一位。
ax.yaxis.get_major_formatter().set_powerlimits((0, 1)) # 将坐标轴的base number设置为一位。
plt.show()
def creat_povray_mesh_of_numberical_verification(output_file):
RI_raw = np.array(
dr.read_csv('data_evaluation_minst/data_center_test/mark_C/0/RI.csv'),
dtype=float)[:, 0]
weights_raw = np.array(dr.read_csv(
'data_evaluation_minst/data_center_test/mark_C/0/test_center_w.csv'),
dtype=float)
x_set = weights_raw[:, 0]
y_set = weights_raw[:, 1]
z_set = weights_raw[:, 2]
idx = x_set >= 0
idx2 = y_set >= 0
idx3 = z_set >= 0
idx = np.bitwise_and(idx, idx2)
idx = np.bitwise_and(idx, idx3)
RI = RI_raw[idx]
x_set = x_set[idx]
y_set = y_set[idx]
z_set = z_set[idx]
RI_norm = np.array(RI / (np.max(RI) - np.min(RI)), dtype=float)
RI_color = np.array(RI_norm * 255, dtype=np.uint8)
im_color = cv2.applyColorMap(RI_color, cv2.COLORMAP_RAINBOW)
fw = open(output_file[0], 'w') # 将要输出保存的文件地址
for i in range(len(RI)):
coord = [x_set[i], RI_norm[i], y_set[i]]
color = im_color[i]
insert_one_ellispon(fw, coord, color)
fw.close()
def draw_summary():
path_list = [
'record/model_cnn_zero/',
'record/multi_label2/',
'record/multi_label3/',
'record/multi_label4/',
'record/multi_label5/',
'record/multi_label6/',
'record/multi_label7/',
'record/multi_label8/',
'record/model_cnn/',
]
file_list = ['C_dis_random.csv', 'E_dis_random.csv', 'W_dis_random.csv']
input_c_dis = []
input_E_dis = []
input_W_dis = []
for path in path_list:
input_c_dis.append(np.array(dr.read_csv(path + file_list[0]), dtype='float')[:, 0])
for path in path_list:
input_E_dis.append(np.array(dr.read_csv(path + file_list[1]), dtype='float')[:, 0])
for path in path_list:
input_W_dis.append(np.array(dr.read_csv(path + file_list[2]), dtype='float')[:, 0])
index = 0
for data in input_c_dis:
x = normalize(data)
y = normalize_y(data)
plt.plot(x, y, label=str(index))
index = index + 1
# popt, pcov = curve_fit(func,x,y_ori)
# a = popt[0]
# b = popt[1]
# y = func(x,a,b)
# plt.plot(x,y)
plt.legend()
plt.show()
index = 0
for data in input_W_dis:
x = normalize(data)
y = normalize_y(data)
plt.plot(x, y, label=str(index))
index = index + 1
plt.legend()
plt.show()
plt.close()
index = 0
for data in input_E_dis:
x = normalize(data)
y = normalize_y(data)
plt.plot(x, y, label=str(index))
index = index + 1
plt.legend()
plt.show()
plt.close()
def calculate_colormap_edis(path_acc, path_loss):
acc = np.array(dr.read_csv(path_acc), dtype=float)
acc_map = np.array(dr.read_csv('radius_test/acc_map.csv'), dtype=float)[:,
0]
loss = np.array(dr.read_csv(path_loss), dtype=float)
loss_map = np.array(dr.read_csv('radius_test/loss_map.csv'),
dtype=float)[:, 0]
acc_mean = np.mean(acc, axis=1)
loss_mean = np.mean(loss, axis=1)
acc_ecolor = set_mapping(acc_map, acc_mean)
dr.save_data(acc_ecolor, 'radius_test/keep/acc_color.csv')
def draw_image(path_color, path_acc):
acc = np.array(dr.read_csv('radius_test/keep/acc.csv'), dtype=float)
norm = np.array(dr.read_csv('radius_test/keep/norms.csv'), dtype=float)[:,
0]
acc_mean = np.mean(acc, axis=1)
acc = acc.transpose()
acc_color = np.array(dr.read_csv('radius_test/keep/acc_color.csv'),
dtype=float) * 2
fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(12, 4))
# 设置标题
ax.set_title('Distribution of Accuracy near the Output Weights',
fontsize=20)
# 绘制小提琴图
parts = ax.violinplot(acc,
showmeans=False,
showmedians=False,
showextrema=True)
sc = ax.scatter(range(1,
len(acc_mean) + 1),
acc_mean,
c=acc_color,
s=np.ones(len(acc_color)) * 50)
cmap = plt.get_cmap('rainbow')
# # 设置填充颜色和边框颜色
i = 0
# for pc in parts['bodies']:
# pc.set_facecolor(cmap(acc_color[i]/100))
# pc.set_edgecolor('black')
# pc.set_alpha(1.0)
# i+=1
labels = ['A', 'B', 'C', 'D']
def set_axis_style(ax, labels):
ax.get_xaxis().set_tick_params(direction='out')
ax.xaxis.set_ticks_position('bottom')
ax.set_xticks(np.arange(1, len(labels) + 1))
ax.set_xticklabels(labels)
ax.set_xlim(0.25, len(labels) + 0.75)
ax.set_xlabel('Sample name')
set_axis_style(ax, norm)
plt.xlabel('2-Norm of Noise', fontsize=20)
plt.ylabel('Accuracy', fontsize=20)
plt.xticks(rotation=30)
cb = plt.colorbar(sc)
cb.set_label('Equivalent Training Steps')
plt.tight_layout()
# plt.xticks(my_x_ticks)
plt.show()
def draw_standard(xcoord,ycoord,output_path = 'no',xaxis = 'blank', yaxis = 'blank',ratio = (8,4),tight_layout = False,font_size = [10,10]):
plt.rcParams['figure.figsize'] = ratio
x = np.array(dr.read_csv(xcoord), dtype=float)[:, 0]
y = np.array(dr.read_csv(ycoord), dtype=float)[:, 0]
plt.xlabel(xaxis, fontsize=font_size[0])
plt.ylabel(yaxis, fontsize=font_size[0])
plt.xticks(fontsize=font_size[1])
plt.yticks(fontsize=font_size[1])
plt.plot(x, y)
if tight_layout:
plt.tight_layout()
if output_path == 'no':
plt.show()
else:
plt.savefig(output_path)
def draw_batch(path, labels = [],output_path = 'no',xaxis = 'blank', yaxis = 'blank',Title = 'blank', hidecoord = False,
range_select = [-1,-1],ratio = (8.0, 4.0),dpi = 100,xoffset = [1,0],
tight_layout = True,font_size = [20,10,10], xticks = [],yticks = [],alpha = 1):
plt.rcParams['figure.figsize'] = ratio
plt.rcParams['figure.dpi'] = dpi # 分辨率
plt.xlabel(xaxis, fontsize=font_size[0])
plt.ylabel(yaxis, fontsize=font_size[0])
plt.xticks(xticks,fontsize=font_size[1])
plt.yticks(yticks,fontsize=font_size[1])
plt.title(Title,fontsize=font_size[0])
if tight_layout:
plt.tight_layout()
array_set = np.array(dr.read_csv(path), dtype=float)
for i in range(len(array_set)):
array = array_set[i]
if not range_select[0] == -1:
array = array[range_select[0]:range_select[1]]
plt.plot(range(len(array)), array, label=labels[i])
# output
plt.legend(fontsize=font_size[2])
if output_path == 'no':
plt.show()
else:
plt.savefig(output_path)
def single_training(file_address,
standard_init='Yes',
standard_training='Yes'):
x_train = cm.x_train
y_train = cm.y_train
if not os.path.exists(file_address): # 判断是否存在文件夹如果不存在则创建为文件夹
os.makedirs(file_address) # makedirs 创建文件时如果路径不存在会创建这个路径
os.makedirs('record/' + file_address)
print
"--- new folder... ---"
else:
print
"--- There is this folder! ---"
if standard_init == 'Yes':
print('standard_init using')
cm.model.load_weights('standard_init.h5')
if standard_training == 'Yes':
training_order = np.array(dr.read_csv('standard_order.csv'),
dtype='int32')[:, 0]
else:
length = x_train.shape[0]
training_order = list(range(length))
random.shuffle(training_order)
print('training_config:', file_address, 'standard training order:',
training_order, 'standard init:', standard_init)
for epoch in range(cm.epochs):
for b in range(x_train.shape[0] // cm.batch_size):
idx = training_order[b * cm.batch_size:(b + 1) * cm.batch_size]
x = x_train[idx]
y = y_train[idx]
l = cm.model.train_on_batch(x, y)
name = file_address + '/' + str(epoch) + 'E' + str(b) + 'b.h5'
cm.model.save(name)
print(name)
def draw_curve_image(curves, pic_name, ratio=1):
csvFile = dr.read_csv(curves)
data = np.array(csvFile, np.float32)
# draw image
fig = plt.figure(figsize=(6, 6))
if ratio != 1:
size = len(data[0]) / ratio
size_i = int(size) + 1
a = np.array(range(len(data[0])))
sample_list = np.append(a[::ratio], len(data[0]) - 1)
print(sample_list)
for i in range(len(data)):
o_data = data[i][sample_list]
plt.plot(range(0, size_i), o_data, label='training accuracy')
else:
for i in range(len(data)):
plt.plot(range(0, len(data[i])),
data[i],
label='training accuracy')
plt.xticks(fontsize=15)
plt.yticks(fontsize=15)
# plt.savefig(pic_name)
plt.show()
def draw_scatter3D(path_set,data_address = 'none',xaxis = 'blank', yaxis = 'blank',ratio = (4,4),ylimitaion = (400,500),axis = [],range_select = [],open_color = True):
plt.rcParams['figure.figsize'] = ratio
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
for path in path_set:
array = np.array(dr.read_csv(path), dtype=float)
if len(range_select) != 0:
array = array[range_select[0]:range_select[1]]
if open_color:
colors = list(range(len(array)))
ax.scatter(array[:, 0], array[:, 1], array[:, 2], c=colors)
else:
ax.scatter(array[:, 0], array[:, 1], array[:, 2])
# plt.show()
if len(axis) != 0:
plt.axis(axis)
plt.xlabel(xaxis)
plt.ylabel(yaxis)
# area = (30 * np.random.rand(N)) ** 2 # 0 to 15 point radii
ax.set_xlabel('X Label')
ax.set_ylabel('Y Label')
ax.set_zlabel('Z Label')
plt.show()
def batch_kl_test(path_d1, path_d2, opath):
file_ls = os.listdir(path_d1)
def sort_key(e):
epoch_str = e.split('.')
return int(epoch_str[0])
output = []
file_ls.sort(key=sort_key)
for file in file_ls:
array_d1 = np.array(dr.read_csv(path_d1 + '/' + file), dtype=float)[:,
0]
array_d2 = np.array(dr.read_csv(path_d2 + '/' + file), dtype=float)[:,
0]
output.append(kl.KL_div(array_d1, array_d2, activation=False))
dr.save_data(output, opath)
def error_label_shift(error_set,
standard_init='Yes',
standard_training='Yes',
gaps=0):
for error in error_set:
x_train = cm.x_train
y_train = cm.y_train
file_address = 'error_label' + str(error)
if not os.path.exists(file_address): # 判断是否存在文件夹如果不存在则创建为文件夹
os.makedirs(file_address) # makedirs 创建文件时如果路径不存在会创建这个路径
os.makedirs('record/' + file_address)
print
"--- new folder... ---"
print
"--- OK ---"
else:
print
"--- There is this folder! ---"
if standard_init == 'Yes':
print('standard_init using')
cm.model.load_weights('cnn_check_standard_init.h5')
if standard_training == 'Yes':
training_order = np.array(
dr.read_csv('cifar10_training_order.csv'), dtype='int32')[:, 0]
else:
length = x_train.shape[0]
training_order = list(range(length))
random.shuffle(training_order)
dr.save_data(training_order, 'templete_training_order.csv')
print('training_config:', file_address, 'standard training order:',
training_order, 'standard init:', standard_init)
#global_shuffle(array, rate):
error_rate = error / 100
y_train_ori = np.copy(y_train)
error_array = y_train[:int(len(y_train) * error_rate)]
random.shuffle(error_array)
y_train[:int(len(y_train) * error_rate)] = error_array
print('global error rate:' +
str(error_onehotlabel_rate(y_train, y_train_ori)))
gap = 0
for epoch in range(cm.epochs):
for b in range(x_train.shape[0] // cm.batch_size):
idx = training_order[b * cm.batch_size:(b + 1) * cm.batch_size]
x = x_train[idx]
y = y_train[idx]
loss, acc = cm.model.train_on_batch(x, y)
print('local error rate:' +
str(error_onehotlabel_rate(y, y_train_ori[idx])))
print('loss: ' + str(loss) + ' acc: ' + str(acc))
if gap == gaps:
name = file_address + '/' + str(epoch) + 'E' + str(
b) + 'b.h5'
cm.model.save(name)
print(name)
gap = 0
else:
gap += 1
def draw_vis_image(labels, points, pic_name):
csvFile = dr.read_csv(labels)
y_data = np.array(csvFile, np.float32)
y = y_data[:, 1]
coordinate = dr.read_csv(points)
encoded_data_mean = np.array(coordinate, np.float32)
encoded_data_output = tf.nn.sigmoid(encoded_data_mean)
sess = tf.Session()
code_output = sess.run(encoded_data_output)
# draw image
fig = plt.figure(figsize=(6, 6))
plt.scatter(code_output[:, 0], code_output[:, 1], c=y)
plt.xticks(fontsize=15)
plt.yticks(fontsize=15)
bar = plt.colorbar()
bar.ax.tick_params(labelsize=15)
plt.savefig(pic_name)
def train_velocity_samples(output_path,
usesameinit=True,
usersameorder=True,
channels=10,
loop=5,
epochs=1,
gap=0):
x_train, x_test, y_train, y_test = create_data_set(list(range(10)), 4000)
v_square_estimate = []
bs = 100
length = x_train.shape[0]
if not os.path.exists(output_path): # 判断是否存在文件夹如果不存在则创建为文件夹
os.makedirs(output_path)
if usersameorder:
if os.path.exists(output_path + '/training_order.csv'):
training_order = np.array(dr.read_csv(output_path +
'/training_order.csv'),
dtype='int32')[:, 0]
else:
training_order = list(range(length))
random.shuffle(training_order)
dr.save_data(training_order, output_path + '/training_order.csv')
if not os.path.exists(output_path + '/weights/'): # 判断是否存在文件夹如果不存在则创建为文件夹
os.makedirs(output_path + '/weights/')
for i in range(loop):
model = create_network(channals=channels)
if usesameinit:
if os.path.exists(output_path + '/0E0b.h5'):
model.load_weights(output_path + '/0E0b.h5')
else:
model.save_weights(output_path + '/0E0b.h5')
if not os.path.exists(output_path + '/weights/' +
str(i)): # 判断是否存在文件夹如果不存在则创建为文件夹
os.makedirs(output_path + '/weights/' + str(i))
count = 0
for epoch in range(epochs):
for b in range(x_train.shape[0] // bs):
idx = training_order[b * bs:(b + 1) * bs]
x = x_train[idx]
y = y_train[idx]
l = model.train_on_batch(x, y)
count += 1
if count > gap:
name = output_path + '/weights/' + str(i) + '/' + str(
epoch) + 'E' + str(b) + 'b.h5'
model.save(name)
print(name)
count = 0
def batch_distance_to_distribution(path, opath):
file_ls = os.listdir(path)
def sort_key(e):
epoch_str = e.split('.')
return int(epoch_str[0])
file_ls.sort(key=sort_key)
for file in file_ls:
array = np.array(dr.read_csv(path + '/' + file), dtype=float)[:, 0]
dis, normal_dis, fanwei = distribution_test(array)
dr.save_data(dis, opath + '/distribution/' + file)
dr.save_data(normal_dis, opath + '/normal_distribution/' + file)
dr.save_data(fanwei, opath + '/fanwei/' + file)
def error_label_shift(error_set, standard_init='Yes', standard_training='Yes'):
for error in error_set:
x_train = cm.x_train
y_train = cm.y_train
file_address = 'error_label' + str(error)
if not os.path.exists(file_address): # 判断是否存在文件夹如果不存在则创建为文件夹
os.makedirs(file_address) # makedirs 创建文件时如果路径不存在会创建这个路径
os.makedirs('record/' + file_address)
print
"--- new folder... ---"
print
"--- OK ---"
else:
print
"--- There is this folder! ---"
if standard_init == 'Yes':
print('standard_init using')
cm.model.load_weights('standard_init.h5')
if standard_training == 'Yes':
training_order = np.array(dr.read_csv('standard_order.csv'),
dtype='int32')[:, 0]
else:
length = x_train.shape[0]
training_order = list(range(length))
random.shuffle(training_order)
print('training_config:', file_address, 'standard training order:',
training_order, 'standard init:', standard_init)
for epoch in range(cm.epochs):
for b in range(x_train.shape[0] // cm.batch_size):
idx = training_order[b * cm.batch_size:(b + 1) * cm.batch_size]
x = x_train[idx]
y = y_train[idx]
yori = np.copy(y)
yori_index = onehot_to_index(y)
gap = int(100 / error)
idr = (np.array(range(cm.batch_size)) % gap == 0)
y_error = y[idr]
random.shuffle(y_error)
y[idr] = y_error
y_index = onehot_to_index(y)
print(
sum(np.array(yori_index) == np.array(y_index)) /
len(y_index))
print(error_onehotlabel_rate(y, yori))
l = cm.model.train_on_batch(x, y)
name = file_address + '/' + str(epoch) + 'E' + str(b) + 'b.h5'
cm.model.save(name)
print(name)
def analysis_mds(path_array, opath=''):
stds = []
avgs = []
cvs = []
file_ls = os.listdir(path_array)
def sort_key(e):
epoch_str = e.split('.')
return int(epoch_str[0])
file_ls.sort(key=sort_key)
for file in file_ls:
mat = np.array(dr.read_csv(path_array + '/' + file), dtype=float)
mn = np.linalg.norm(mat, axis=1)
std = np.std(mn)
avg = np.mean(mn)
cv = std / avg
avgs.append(avg)
stds.append(std)
cvs.append(cv)
print('ok')
if len('opath') != 0:
dr.save_data(stds, opath + '/stds.csv')
dr.save_data(avgs, opath + '/avgs.csv')
dr.save_data(cvs, opath + '/cvs.csv')
plt.plot(range(len(stds)), stds)
plt.savefig(opath + '/stds.png')
plt.close()
plt.plot(range(len(avgs)), avgs)
plt.savefig(opath + '/avgs.png')
plt.close()
plt.plot(range(len(cvs)), cvs)
plt.savefig(opath + '/cvs.png')
plt.close()
def single_training(file_address):
x_train = cm.x_train
y_train = cm.y_train
if not os.path.exists(file_address): # 判断是否存在文件夹如果不存在则创建为文件夹
os.makedirs(file_address) # makedirs 创建文件时如果路径不存在会创建这个路径
os.makedirs('record/' + file_address)
print
"--- new folder... ---"
print
"--- OK ---"
else:
print
"--- There is this folder! ---"
cm.model.load_weights('standard_init.h5')
training_order = np.array(dr.read_csv('standard_order.csv'),
dtype='int32')[:, 0]
loss = []
acc = []
for epoch in range(cm.epochs):
for b in range(x_train.shape[0] // cm.batch_size):
idx = training_order[b * cm.batch_size:(b + 1) * cm.batch_size]
x = x_train[idx]
y = y_train[idx]
l = cm.model.train_on_batch(x, y)
name = file_address + '/' + str(epoch) + 'E' + str(b) + 'b.h5'
cm.model.save(name)
print(name + ' ' + str(l))
loss.append(l[0])
acc.append(l[1])
if (l[1] > 0.99):
dr.save_data(acc, 'radius_test/acc_map.csv')
dr.save_data(loss, 'radius_test/loss_map.csv')
return loss, acc
dr.save_data(acc, 'radius_test/acc_map.csv')
dr.save_data(loss, 'radius_test/loss_map.csv')
return loss, acc
def draw_bar(path_array, labels = [],output_path = 'no',xaxis = 'blank', yaxis = 'blank',ratio = (8.0, 4.0),dpi = 100,xoffset = [1,0],tight_layout = True,font_size = [20,10,10], Xstick = [],Title = 'no',ticker_space = 20,alpha = 1,
x_rotation = 0,y_rotation = 0,x_proportion = False):
fig, ax = plt.subplots(1, 1)
plt.rcParams['figure.figsize'] = ratio
plt.rcParams['figure.dpi'] = dpi # 分辨率
plt.xlabel(xaxis, fontsize=font_size[0])
plt.ylabel(yaxis, fontsize=font_size[0])
plt.xticks(fontsize=font_size[1],rotation = x_rotation)
plt.yticks(fontsize=font_size[1],rotation = y_rotation)
if not Title == 'no':
plt.title(Title,fontsize=font_size[0])
index = 0
for path in path_array:
array = np.array(dr.read_csv(path), dtype=float)[:, 0]
if len(Xstick)== 0:
x = np.array(range(len(array))) * xoffset[0] + xoffset[1]
plt.bar(x, array, label=labels[index],alpha = alpha)
# ax = plt.figure().axis()
else:
x = np.array(range(len(array))) * xoffset[0] + xoffset[1]
plt.bar(x,array,label=labels[index],tick_label = Xstick,alpha = alpha)
index = index + 1
ax.xaxis.set_major_locator(ticker.MultipleLocator(ticker_space))
if x_proportion:
def to_percent(temp, position):
return str(np.around(100 * temp,decimals=2)) + '%'
plt.gca().yaxis.set_major_formatter(ticker.FuncFormatter(to_percent))
plt.legend(fontsize=font_size[2])
if tight_layout:
plt.tight_layout()
if output_path == 'no':
plt.show()
else:
plt.savefig(output_path)
def draw_scatter(path_set,data_address = 'none',xaxis = 'blank', yaxis = 'blank',ratio = (4,4),ylimitaion = (400,500),axis = [],range_select = [],open_color = True,font_size = 20):
plt.rcParams['figure.figsize'] = ratio
for path in path_set:
array = np.array(dr.read_csv(path), dtype=float)
if len(range_select) != 0:
array = array[range_select[0]:range_select[1]]
x = array[:, 0]
y = array[:, 1]
if open_color:
colors = list(range(len(array)))
plt.scatter(x,y, c=colors, alpha=0.5)
else:
plt.scatter(x, y, alpha=0.5)
# plt.show()
if len(axis) != 0:
plt.axis(axis)
if xaxis != 'blank':
plt.xlabel(xaxis)
if yaxis!='blank':
plt.ylabel(yaxis)
plt.show()
def draw(path_array,
labels=[],
output_path='no',
xaxis='blank',
yaxis='blank',
range_select=[-1, -1],
ratio=(8.0, 4.0),
dpi=100,
xoffset=[1, 0],
tight_layout=True,
font_size=[20, 10, 10],
setXcoord=False,
Xcoord=[],
Title='no',
alpha=1):
plt.rcParams['figure.figsize'] = ratio
plt.rcParams['figure.dpi'] = dpi # 分辨率
plt.xlabel(xaxis, fontsize=font_size[0])
plt.ylabel(yaxis, fontsize=font_size[0])
plt.xticks(fontsize=font_size[1])
plt.yticks(fontsize=font_size[1])
if not Title == 'no':
plt.title(Title, fontsize=font_size[0])
if len(labels) == 0:
# plt.axes(xscale='log')
for path in path_array:
array = np.array(dr.read_csv(path), dtype=float)[:, 0]
if not setXcoord:
if range_select[0] == -1:
x = np.array(range(len(array))) * xoffset[0] + xoffset[1]
plt.plot(x, array)
else:
array = array[range_select[0]:range_select[1]]
x = np.array(range(len(array))) * xoffset[0] + xoffset[1]
plt.plot(x, array)
else:
if range_select[0] == -1:
plt.plot(Xcoord, array)
else:
array = array[range_select[0]:range_select[1]]
Xcoord = Xcoord[range_select[0]:range_select[1]]
plt.plot(Xcoord, array)
if tight_layout:
plt.tight_layout()
plt.show()
else:
index = 0
for path in path_array:
array = np.array(dr.read_csv(path), dtype=float)[:, 0]
if not setXcoord:
if range_select[0] == -1:
x = np.array(range(len(array))) * xoffset[0] + xoffset[1]
plt.plot(x, array, label=labels[index])
else:
array = array[range_select[0]:range_select[1]]
x = np.array(range(len(array))) * xoffset[0] + xoffset[1]
plt.plot(x, array, label=labels[index])
else:
if range_select[0] == -1:
plt.plot(Xcoord, array, label=labels[index])
else:
array = array[range_select[0]:range_select[1]]
Xcoord = Xcoord[range_select[0]:range_select[1]]
plt.plot(Xcoord, array, label=labels[index])
index = index + 1
plt.legend(fontsize=font_size[2])
if tight_layout:
plt.tight_layout()
if output_path == 'no':
plt.show()
else:
plt.savefig(output_path)
# begin_path = ['cnn_mnist_exp1/begin/0.h5','cnn_mnist_exp1/begin/1.h5','cnn_mnist_exp1/begin/2.h5','cnn_mnist_exp1/begin/3.h5','cnn_mnist_exp1/begin/4.h5',
# 'cnn_mnist_exp1/begin/5.h5','cnn_mnist_exp1/begin/6.h5', 'cnn_mnist_exp1/begin/7.h5','cnn_mnist_exp1/begin/8.h5','cnn_mnist_exp1/begin/9.h5',
# 'cnn_mnist_exp1/begin/10.h5','cnn_mnist_exp1/begin/11.h5','cnn_mnist_exp1/begin/12.h5','cnn_mnist_exp1/begin/13.h5','cnn_mnist_exp1/begin/14.h5',
# 'cnn_mnist_exp1/begin/15.h5','cnn_mnist_exp1/begin/16.h5','cnn_mnist_exp1/begin/17.h5','cnn_mnist_exp1/begin/18.h5','cnn_mnist_exp1/begin/19.h5']
# end_path = ['cnn_mnist_exp1/end/0.h5','cnn_mnist_exp1/end/1.h5','cnn_mnist_exp1/end/2.h5','cnn_mnist_exp1/end/3.h5','cnn_mnist_exp1/end/4.h5',
# 'cnn_mnist_exp1/end/5.h5','cnn_mnist_exp1/end/6.h5', 'cnn_mnist_exp1/end/7.h5','cnn_mnist_exp1/end/8.h5','cnn_mnist_exp1/end/9.h5',
# 'cnn_mnist_exp1/end/10.h5','cnn_mnist_exp1/end/11.h5','cnn_mnist_exp1/end/12.h5','cnn_mnist_exp1/end/13.h5','cnn_mnist_exp1/end/14.h5',
# 'cnn_mnist_exp1/end/15.h5','cnn_mnist_exp1/end/16.h5','cnn_mnist_exp1/end/17.h5','cnn_mnist_exp1/end/18.h5','cnn_mnist_exp1/end/19.h5']
# out_path = 'cnn_mnist_exp1/distance.csv'
# compare_two_model_batch(begin_path,end_path,out_path,kl.E_dis)
# path = ['standard_init.h5','standard_init.h5','standard_init.h5','standard_init.h5','standard_init.h5','standard_init.h5']
# path = ['cnn_mlabel1/1009.h5','cnn_mlabel2/1009.h5','cnn_mlabel4/1009.h5','cnn_mlabel6/1009.h5','cnn_mlabel8/1009.h5','cnn_mlabel10/1009.h5']
# tpath = ['cnn_mlabel1/4645.h5','cnn_mlabel2/4645.h5','cnn_mlabel4/4645.h5','cnn_mlabel6/4645.h5','cnn_mlabel8/4645.h5','cnn_mlabel10/4645.h5']
# out_path = 'figures/distance_test.csv'
# compare_two_model_batch(path,tpath,out_path,kl.E_dis)
# path = ['cnn_mlabel2','cnn_mlabel4','cnn_mlabel6','cnn_mlabel8','cnn_mlabel10']
# tpath = ['cnn_mlabel2/461.h5','cnn_mlabel4/461.h5','cnn_mlabel6/461.h5','cnn_mlabel8/461.h5','cnn_mlabel10/461.h5']
# opath = ['figures/']
# analyse_sequence(path,tpath,[kl.E_dis],['E_div'],output_path_set= opath,keyfunc=sort_key_index,Loss_Accuracy=False)
array = np.array(dr.read_csv('figures/E_div.csv'), dtype=float)
for i in range(len(array)):
plt.plot(range(len(array[i])), array[i])
plt.xlabel('test')
plt.ylabel('ytest')
plt.xticks([])
plt.yticks([])
plt.show()
def draw_contour(RI_path,weight_path,output_path,sample_rate = 0.01,font_size = [20,10,10]):
RI = np.array(dr.read_csv(RI_path),dtype=float)
test_center_w = np.array(dr.read_csv(weight_path),dtype=float)
zz = np.array(RI, dtype='float')
dim = range(3)
dim_set = combinations(dim, 2)
for dim_select in dim_set:
key = []
for w in test_center_w:
w_d1 = optimzie_key(w[dim_select[0]], 2)
w_d2 = optimzie_key(w[dim_select[1]], 2)
mark1 = 'x' + str(w_d1)
mark2 = 'y' + str(w_d2)
key.append(mark1 + mark2)
dic = dict(zip(key, zz))
xx = np.arange(0, 1 + 0.01, sample_rate)
yy = np.arange(0, 1 + sample_rate, sample_rate)
X, Y = np.meshgrid(xx, yy)
Z = np.zeros(X.shape)
for i in range(len(xx)):
for j in range(len(xx)):
w_d1 = optimzie_key(X[i, j], 2)
w_d2 = optimzie_key(Y[i, j], 2)
mark1 = 'x' + str(w_d1)
mark2 = 'y' + str(w_d2)
if mark1 + mark2 in dic:
Z[i, j] = dic[mark1 + mark2]
else:
Z[i, j] = 0
# plt.rcParams['figure.figsize'] = [6,4]
ax3 = plt.axes(projection='3d')
handle = ax3.plot_surface(X, Y, Z, cmap='nipy_spectral')
zoom = Z.max() - Z.min()
# rag = np.arange(0, 10, 0.2) * ratio / 10 + Z.min() + 0.0001
# ax3.contour(X, Y, Z,rag, offset=0, cmap='hot')
# ax3.set_zlim(0, 1) # 设置z的范围
ax3.set_zlabel('RI', fontsize=font_size[0])
# ax3.set_zticks([])
plt.xlabel('$s_ ' + str(dim_select[0]) + '$ weight', fontsize=font_size[0])
plt.ylabel('$s_ ' + str(dim_select[1]) + '$ weight', fontsize=font_size[0])
# fig = plt.figure()
plt.colorbar(handle)
plt.tight_layout()
plt.show()
plt.close()
plt.rcParams['figure.figsize'] = [4.2, 4]
plt.xlabel('$s_ ' + str(dim_select[0]) + '$ weight', fontsize=font_size[0])
plt.ylabel('$s_ ' + str(dim_select[1]) + '$ weight', fontsize=font_size[0])
zoom = Z.max() - Z.min()
rag = np.arange(0, 10, 0.2) * zoom / 10 + Z.min()+0.0001
C = plt.contour(X, Y, Z, rag, cmap='rainbow')
plt.tight_layout()
plt.show()
# plt.clabel(C, inline=True, fontsize=10) # 在等高线上标出对应的z值
# ax3.set_zlim(-1, 1) # 设置z的范围
# plt.savefig(output_path + str(dim_select[0]) + '_' + str(dim_select[1]) + 'contour.png')
plt.close()
def sort_key(e):
value = os.path.splitext(e)
return int(value[0])
file_ls.sort(key=sort_key)
mean_support = np.zeros(len(file_ls))
std_support = np.zeros(len(file_ls))
mean_all = np.zeros(len(file_ls))
std_all = np.zeros(len(file_ls))
i = 0
for file in file_ls:
distance = np.array(dr.read_csv(data_path + file), dtype=float)[:, 0]
if len(distance) == 0:
break
mean = np.mean(distance)
std = np.std(distance)
np.random.seed(0)
s = np.random.normal(mean, std, 10000)
# plt.hist(s, bins=100, normed=True, alpha=0.5,label='Normal')
# plt.hist(distance, bins=100, normed=True, alpha=0.5,label='Distance')
# plt.legend()
# plt.savefig('QMCM_simulation/images/'+str(i)+'.png')
# plt.close()
mean_support[i] = np.mean(distance)
std_support[i] = np.std(distance)
print('For this program, we provide following functions: \n',
'Performance comparing, Wasserstein distance decreasing comparing')
str = input('Please enter your command:')
if str == 'Performance comparing':
str = input('Please enter the amount of your input:')
num = int(str)
list = []
namelist = []
for i in range(num):
path = input(
'Please enter the address of one record : (for example ../performance_record/****.csv)'
)
list.append(np.array(dr.read_csv(path), 'float32'))
namelist.append('No.' + '%04d' % (i) + 'record')
draw_plot(list, namelist, 'Epoch', 'mAP @ IoU = 50',
'Performance on Worker-Dataset')
elif str == 'Wasserstein distance decreasing comparing':
str = input('Please enter the amount of your input:')
num = int(str)
list = []
namelist = []
for i in range(num):
path = input(
'Please enter the address of one record : (for example ../performance_record/****.csv)'
)
list.append(np.array(dr.read_csv(path), 'float32'))
namelist.append('No.' + '%04d' % (i) + 'record')
draw_plot(list, namelist, 'Epoch', 'Wasserstein Distance')
