def get_intersection_point(buy_x_list, buy_y_list, sell_x_list, sell_y_list, time=None):
#calculate intersection point
f_buy = lambda x: interp(x, buy_x_list, buy_y_list)
f_sell = lambda x: interp(x, sell_x_list, sell_y_list)
intersect_x = fsolve(lambda x : f_sell(x) - f_buy(x), 10000)
return intersect_x, f_buy(intersect_x)
def plot_price_volume(buy_prices, buy_volumes, sell_prices, sell_volumes, show_intersections=False):
intersect_x = None
intersect_y = None
for i in range(0, len(buy_prices)):
x_buy = [r for r in buy_volumes[i]]
y_buy = [r for r in buy_prices[i]]
x_sell = [r for r in sell_volumes[i]]
y_sell = [r for r in sell_prices[i]]
f_buy = lambda x: interp(x, x_buy, y_buy)
f_sell = lambda x: interp(x, x_sell, y_sell)
if show_intersections == True:
intersect_x, intersect_y = get_intersection_point(x_buy, y_buy, x_sell, y_sell, time=str(times[i]))
plt.plot(intersect_x, intersect_y, 'ko')
plt.plot(x_buy, f_buy(x_buy), 'k-', label='Demand Curve')#, linewidth=0.2, markersize=0.1)
plt.plot(x_sell, f_sell(x_sell), 'k--', label='Supply Curve')
#plt.annotate(str(intersect_x[0])+ ' | ' + str(intersect_y[0]), xy=(intersect_x, intersect_y),
# xytext=(intersect_x-3000, intersect_y-100))
#plt.plot(41500, 80.16, 'ro')
plt.xlabel("MWh")
plt.ylabel("EUR/MWh")
plt.legend(loc='best')
plt.ylim(-200, 2000)
plt.yticks(arange(-200, 2000, 200.0))
plt.grid(axis='y')
plt.autoscale()
plt.show()
def interpolateList(x1,x2,xn,y1,y2):
'''
Function to interpolate between lists y1 and y2 that are located at
x1 and x2. Returns a new list yn at xn. Interpolation is done linear
'''
yn = []
for i in range(len(y1)):
j = interp(xn,[x1,x2],[y1[i],y2[i]])
yn.append(j)
return yn
def interpolateList(x1, x2, xn, y1, y2):
'''
Function to interpolate between lists y1 and y2 that are located at
x1 and x2. Returns a new list yn at xn. Interpolation is done linear
'''
yn = []
for i in range(len(y1)):
j = interp(xn, [x1, x2], [y1[i], y2[i]])
yn.append(j)
return yn
def getNearest(self, FLList, FL, MA, T):
'''
getNearest is a function to interpolate in a CPACS engine performance map.
'''
def getUpLow(List, Target):
Plus = [99999999., 0]
Minus = [0., 0]
for item in List:
# Set the lower value for the interpolation of Flight Level
if item[0] - Target > Minus[0] - Target and item[0] - Target < 0.:
Minus = item
# Set the upper value for the interpolation of Flight Level
if item[0] - Target < Plus[0] - Target and item[0] - Target > 0.:
Plus = item
if List[-1][0] < Target:
Minus = List[-2]
Plus = List[-1]
self.log.warning('VAMPzero SFC: Interpolation Error need to extrapolate! Target value is: %s' % Target)
self.log.warning('VAMPzero SFC: New up: %s and low: %s' % (Plus[0], Minus[0]))
return Plus, Minus
FLplus, FLminus = getUpLow(FLList, FL)
FLplusMAplus, FLplusMAminus = getUpLow(FLplus[1], MA)
FLminusMAplus, FLminusMAminus = getUpLow(FLminus[1], MA)
FLplusMAplusTplus, FLplusMAplusTminus = getUpLow(FLplusMAplus[1], T)
FLplusMAminusTplus, FLplusMAminusTminus = getUpLow(FLplusMAminus[1], T)
FLminusMAplusTplus, FLminusMAplusTminus = getUpLow(FLminusMAplus[1], T)
FLminusMAminusTplus, FLminusMAminusTminus = getUpLow(FLminusMAminus[1], T)
# Do the interpolations
SFCFLplusMaplus = interp(T, [FLplusMAplusTminus[0], FLplusMAplusTplus[0]],
[FLplusMAplusTminus[1], FLplusMAplusTplus[1]])
SFCFLplusMaminus = interp(T, [FLplusMAminusTminus[0], FLplusMAminusTplus[0]],
[FLplusMAminusTminus[1], FLplusMAminusTplus[1]])
SFCFLminusMaplus = interp(T, [FLminusMAplusTminus[0], FLminusMAplusTplus[0]],
[FLminusMAplusTminus[1], FLminusMAplusTplus[1]])
SFCFLminusMaminus = interp(T, [FLminusMAminusTminus[0], FLminusMAminusTplus[0]],
[FLminusMAminusTminus[1], FLminusMAminusTplus[1]])
SFCFLplus = interp(MA, [FLplusMAminus[0], FLplusMAplus[0]], [SFCFLplusMaminus, SFCFLplusMaplus])
SFCFLminus = interp(MA, [FLminusMAminus[0], FLminusMAplus[0]], [SFCFLminusMaminus, SFCFLminusMaplus])
SFC = interp(FL, [FLminus[0], FLplus[0]], [SFCFLminus, SFCFLplus])
return SFC
def main():
class_num = 3
vaild_ttrans = Transforms.Compose([
# Transforms.RandomVerticalFlip(p=0.5),
# transforms.RandomRotation(30),
# transforms.RandomCrop(100),
# transforms.RandomResizedCrop(112),
# Transforms.ColorJitter(brightness=0.5),
# transforms.RandomErasing(p=0.2, scale=(0.02, 0.03), ratio=(0.3, 0.3), value=0, ),
Transforms.Resize((24, 24)),
Transforms.ToTensor(),
Transforms.Normalize((0.45, 0.448, 0.455), (0.082, 0.082, 0.082)),
])
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
txt_path = '/media/omnisky/D4T/JSH/faceFenlei/eye/mbhlk_hl_0128/mix_train.txt'
vaild_txt = '/media/omnisky/D4T/JSH/faceFenlei/eye/mbhlk_hl_0128/mix_valid.txt'
# model
mixnet = MixNet(input_size=(24,24), num_classes=3)
weight_dict = torch.load("/media/omnisky/D4T/JSH/faceFenlei/Projects/hul_eye_class/weight/relabel_04_mix_SGD_mutillabel_24_24_20210302/Mixnet_epoch_49.pth")
new_state_dict = OrderedDict()
for k, v in weight_dict.items():
name = k[7:]
new_state_dict[name] = v
mixnet.load_state_dict(new_state_dict)
# stat(net,(3,48,48))
mixnet.to('cuda:0')
mixnet.eval()
vaild_data = mbhk_get_signal_eye(vaild_txt,vaild_ttrans)
valid_data_loader = DataLoader(vaild_data,batch_size=128,shuffle=False,num_workers=12)
score_list = [] #存储预测得分
label_list = [] #存储真实标签
with torch.no_grad():
for imgs,labels,_ in valid_data_loader:
for timg in imgs:
test_result = mixnet(timg.cuda())
# result = torch.max(test_result,1)[1]
result = torch.nn.functional.softmax(test_result,dim=1)
score_list.extend(result.cpu().numpy())
label_list.extend(torch.nn.functional.one_hot(labels,num_classes=3).numpy())
tlabel_list = np.array(label_list).reshape((-1,3))
tscore_list = np.array(score_list).reshape((-1,3))
# 调用sklearn,计算每个类别对应的fpr和tpr
fpr_dict = dict()
tpr_dict = dict()
roc_auc_dict = dict()
for i in range(class_num):
fpr_dict[i],tpr_dict[i],_ = roc_curve(tlabel_list[:,i],tscore_list[:,i])
roc_auc_dict[i] = auc(fpr_dict[i],tpr_dict[i])
# Compute micro-average ROC curve and ROC area
fpr_dict["micro"],tpr_dict["micro"],_ = roc_curve(tlabel_list.ravel(),tscore_list.ravel())
roc_auc_dict["micro"] = auc(fpr_dict["micro"],tpr_dict["micro"])
#绘制所有类别平均的roc曲线
# macro
# First aggregate all false positive rates
all_fpr = np.unique(np.concatenate([fpr_dict[i] for i in range(class_num)]))
# Then interpolate all ROC curves at this points
mean_ptr = np.zeros_like(all_fpr)
for i in range(class_num):
mean_ptr += interp(all_fpr,fpr_dict[i],tpr_dict[i])
# Finally average it and compute AUC
mean_ptr /= class_num
fpr_dict["macro"] = all_fpr
tpr_dict["macro"] = mean_ptr
roc_auc_dict["macro"] = auc(fpr_dict['macro'],tpr_dict["macro"])
plt.figure()
lw = 2
plt.plot(fpr_dict["micro"], tpr_dict["micro"],
label='micro-average ROC curve (area = {0:0.2f})'
''.format(roc_auc_dict["micro"]),
color='deeppink', linestyle=':', linewidth=4)
plt.plot(fpr_dict["macro"], tpr_dict["macro"],
label='macro-average ROC curve (area = {0:0.2f})'
''.format(roc_auc_dict["macro"]),
color='navy', linestyle=':', linewidth=4)
colors = cycle(['aqua', 'darkorange', 'cornflowerblue'])
for i, color in zip(range(class_num), colors):
plt.plot(fpr_dict[i], tpr_dict[i], color=color, lw=lw,
label='ROC curve of class {0} (area = {1:0.2f})'
''.format(i, roc_auc_dict[i]))
plt.plot([0, 1], [0, 1], 'k--', lw=lw)
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('Some extension of Receiver operating characteristic to multi-class')
plt.legend(loc="lower right")
plt.savefig('set113_roc.jpg')
plt.show()
def plot_RR(y_true, y_pred, classes, title=None):
"""
:param y_true: list [0, 1, 2]
:param y_pred: list [0, 1, 2]
:param classes: list ["0", "1", "2"]
:param title: roc
:return: save roc image in path "metric/"
"""
y_true = label_binarize(y_true, classes=[i for i in range(len(classes))])
# y_pred = np.asarray(y_pred)
# �����꣺�����ʣ�False Positive Rate , FPR��
# Compute RR curve and RR area for each class
fpr = dict()
tpr = dict()
pr_auc = dict()
for i in range(len(classes)):
fpr[i], tpr[i], _ = precision_recall_curve(y_true[:, i], y_pred[:, i])
# temp = np.sort(fpr[i])
fpr[i][0] = 0.0
pr_auc[i] = auc(np.sort(fpr[i]), tpr[i])
#
# Compute micro-average RR curve and RR area
fpr["micro"], tpr["micro"], _ = precision_recall_curve(y_true.ravel(), y_pred.ravel())
fpr["micro"][0] = 0
pr_auc["micro"] = auc(np.sort(fpr["micro"]) , tpr["micro"])
# Compute macro-average RR curve and RR area
# First aggregate all false positive rates
all_fpr = np.unique(np.concatenate([fpr[i] for i in range(len(classes))]))
# Then interpolate all RR curves at this points
mean_tpr = np.zeros_like(all_fpr)
for i in range(len(classes)):
mean_tpr += interp(all_fpr, fpr[i], tpr[i])
# Finally average it and compute AUC
mean_tpr /= len(classes)
fpr["macro"] = all_fpr
tpr["macro"] = mean_tpr
pr_auc["macro"] = auc(fpr["macro"], tpr["macro"])
# Plot all RR curves
lw = 2
plt.figure()
plt.plot(fpr["micro"], tpr["micro"],
label='micro-average RR curve (area = {0:0.2f})'
''.format(pr_auc["micro"]),
color='deeppink', linestyle=':', linewidth=4)
plt.plot(fpr["macro"], tpr["macro"],
label='macro-average RR curve (area = {0:0.2f})'
''.format(pr_auc["macro"]),
color='navy', linestyle=':', linewidth=4)
colors = cycle(['aqua', 'darkorange', 'cornflowerblue'])
for i, color in zip(range(len(classes)), colors):
plt.plot(fpr[i], tpr[i], color=color, lw=lw,
label='RR curve of class {0} (area = {1:0.2f})'
''.format(classes[i], pr_auc[i]))
plt.plot([0, 1], [0, 1], 'k--', lw=lw)
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('Some extension of Receiver operating characteristic to multi-class')
plt.legend(loc="lower right")
plt.grid()
plt.savefig("metric/RR_{}.png".format(len(classes)))
plt.show()
def getNearest(self, FLList, FL, MA, T):
'''
getNearest is a function to interpolate in a CPACS engine performance map.
'''
def getUpLow(List, Target):
Plus = [99999999., 0]
Minus = [0., 0]
for item in List:
# Set the lower value for the interpolation of Flight Level
if item[0] - Target > Minus[0] - Target and item[
0] - Target < 0.:
Minus = item
# Set the upper value for the interpolation of Flight Level
if item[0] - Target < Plus[0] - Target and item[
0] - Target > 0.:
Plus = item
if List[-1][0] < Target:
Minus = List[-2]
Plus = List[-1]
self.log.warning(
'VAMPzero SFC: Interpolation Error need to extrapolate! Target value is: %s'
% Target)
self.log.warning('VAMPzero SFC: New up: %s and low: %s' %
(Plus[0], Minus[0]))
return Plus, Minus
FLplus, FLminus = getUpLow(FLList, FL)
FLplusMAplus, FLplusMAminus = getUpLow(FLplus[1], MA)
FLminusMAplus, FLminusMAminus = getUpLow(FLminus[1], MA)
FLplusMAplusTplus, FLplusMAplusTminus = getUpLow(FLplusMAplus[1], T)
FLplusMAminusTplus, FLplusMAminusTminus = getUpLow(FLplusMAminus[1], T)
FLminusMAplusTplus, FLminusMAplusTminus = getUpLow(FLminusMAplus[1], T)
FLminusMAminusTplus, FLminusMAminusTminus = getUpLow(
FLminusMAminus[1], T)
# Do the interpolations
SFCFLplusMaplus = interp(T,
[FLplusMAplusTminus[0], FLplusMAplusTplus[0]],
[FLplusMAplusTminus[1], FLplusMAplusTplus[1]])
SFCFLplusMaminus = interp(
T, [FLplusMAminusTminus[0], FLplusMAminusTplus[0]],
[FLplusMAminusTminus[1], FLplusMAminusTplus[1]])
SFCFLminusMaplus = interp(
T, [FLminusMAplusTminus[0], FLminusMAplusTplus[0]],
[FLminusMAplusTminus[1], FLminusMAplusTplus[1]])
SFCFLminusMaminus = interp(
T, [FLminusMAminusTminus[0], FLminusMAminusTplus[0]],
[FLminusMAminusTminus[1], FLminusMAminusTplus[1]])
SFCFLplus = interp(MA, [FLplusMAminus[0], FLplusMAplus[0]],
[SFCFLplusMaminus, SFCFLplusMaplus])
SFCFLminus = interp(MA, [FLminusMAminus[0], FLminusMAplus[0]],
[SFCFLminusMaminus, SFCFLminusMaplus])
SFC = interp(FL, [FLminus[0], FLplus[0]], [SFCFLminus, SFCFLplus])
return SFC
