def make_ts_area_plot(vecs, cap, wt, rb):
plt.figure()
df = get_metrics(vecs, cap, wt, rb)
subfields = [
"empty_waiting", "empty_rebalancing", "empty_moving_to_pickup"
]
subfields.extend(["time_pass_%d" % i for i in xrange(1, cap + 1)])
df_small = df[subfields].copy()
ax = df_small.plot(kind="area", colormap="rainbow", figsize=(4, 2.2))
labels = ["Waiting", "Rebalancing", "Picking Up"]
labels.extend(["N. Pass: %d" % n for n in xrange(1, cap + 1)])
handles, _ = ax.get_legend_handles_labels()
handles = fix_area_handles(handles)
lgd = ax.legend(reversed(handles),
reversed(labels),
loc='center left',
bbox_to_anchor=(1.0, 0.5),
borderaxespad=0,
handletextpad=0)
d_str = "N. Vecs: {}, Cap: {}, M.W.T: {}".format(vecs, cap, wt, rb)
ax.set_title("Vehicle Occupancy Over Time \nw/ " + d_str)
max_x_ticks = ax.get_xticks()[-1]
ax.set_xticks(np.linspace(0, max_x_ticks - 4720, 8))
dr = pd.date_range(start="05-05-13", periods=len(ax.get_xticks()))
dr = dr.map(lambda t: t.strftime("%a"))
ax.set_xticklabels(dr)
vals = ax.get_yticks()
ax.set_yticklabels(['{:3.0f}%'.format(x / 10) for x in vals])
# ax.set_xlabel("Time")
plt.savefig("figs/ts-area-v{}-c{}-w{}.png".format(vecs, cap, wt),
bbox_extra_artists=(lgd, ),
bbox_inches='tight')
plt.close()
def create_and_evaluate_RF(dic):
rf = RandomForestClassifier(**dic, n_jobs=n_jobs)
rf.fit(train_samples, train_labels)
predictions = rf.predict(test_samples)
_, _, _, f1 = get_metrics(test_labels, predictions, get_cm=False)
print(f'Random Forrest number {i} : f1 - {f1}')
return f1
def make_ts_area_plot(vecs, cap, wt, rb):
plt.figure()
df = get_metrics(vecs, cap, wt, rb)
subfields = ["empty_waiting", "empty_rebalancing",
"empty_moving_to_pickup"]
subfields.extend(["time_pass_%d" % i for i in xrange(1, cap + 1)])
df_small = df[subfields].copy()
ax = df_small.plot(kind="area", colormap="rainbow",
figsize=(4, 2.2))
labels = ["Waiting", "Rebalancing", "Picking Up"]
labels.extend(["N. Pass: %d" % n for n in xrange(1, cap + 1)])
handles, _ = ax.get_legend_handles_labels()
handles = fix_area_handles(handles)
lgd = ax.legend(reversed(handles),
reversed(labels),
loc='center left',
bbox_to_anchor=(1.0, 0.5),
borderaxespad=0,
handletextpad=0)
d_str = "N. Vecs: {}, Cap: {}, M.W.T: {}".format(vecs, cap, wt, rb)
ax.set_title("Vehicle Occupancy Over Time \nw/ " + d_str)
max_x_ticks = ax.get_xticks()[-1]
ax.set_xticks(np.linspace(0, max_x_ticks - 4720, 8))
dr = pd.date_range(start="05-05-13", periods=len(ax.get_xticks()))
dr = dr.map(lambda t: t.strftime("%a"))
ax.set_xticklabels(dr)
vals = ax.get_yticks()
ax.set_yticklabels(['{:3.0f}%'.format(x / 10) for x in vals])
# ax.set_xlabel("Time")
plt.savefig("figs/ts-area-v{}-c{}-w{}.png".format(vecs, cap, wt),
bbox_extra_artists=(lgd,), bbox_inches='tight')
plt.close()
def make_ts_plot(vecs, wt, rb, field):
# fmt = DateFormatter("%a")
# matplotlib.rc("font", weight="bold")
# matplotlib.rc("axes", labelweight="bold")
# matplotlib.rc("figure", titleweight="bold")
fig, ax = plt.subplots()
fig.set_size_inches(4, 2.46)
for cap, clr in zip(caps, clrs):
df = get_metrics(vecs, cap, wt, 0)
locs, labels = plt.xticks()
_, dts = plot_ts(df,
field,
"o",
color=clr,
alpha=1,
label=str(cap),
markersize=4)
ticks = [min(dts)] + list(ax.get_xticks()) + [max(dts)]
new_ticks = list()
for i in xrange(len(ticks) - 1):
new_ticks.append(ticks[i])
new_ticks.append(0.5 * (ticks[i] + ticks[i + 1]))
new_ticks.append(ticks[-1])
ax.set_xticks(new_ticks)
ticklabels = "| Su | Mo | Tu | We | Th | Fr | Sa |".split(" ")
ax.set_xticklabels(ticklabels)
lgd = plt.legend(loc="center left",
fancybox=True,
shadow=True,
bbox_to_anchor=(1, 0.5),
title="Capacity")
lgd.get_title().set_fontsize(15)
set_legend_marker_size(lgd, 15)
plt.ylabel(prettify(field))
if "%" in prettify(field):
ax.set_ylim([0, 1])
vals = ax.get_yticks()
ax.set_yticklabels(['{:3.0f}%'.format(x * 100) for x in vals])
# fig.autofmt_xdate()
# plt.title("N. Vecs: {}, M.W.T: {}".format(vecs, wt))
plt.savefig("figs/ts-{}-v{}-w{}.png".format(field, vecs, wt),
bbox_extra_artists=(lgd, ),
bbox_inches='tight')
plt.close()
def get_avg_dataframe():
cols = ["predictions", "vehicles", "waiting_time", "capacity"] + fields \
+ ["n_shared_per_passenger"]
data = pd.DataFrame(columns=cols)
counter = 0
gen = product(predictions, vehicles, caps, waiting_times)
for (p, v, cap, wt) in gen:
f_vals = list()
try:
df = get_metrics(v, cap, wt, p)
for field in fields:
f_vals.append(np.mean(df[field]))
data.loc[counter] = [p, int(v), int(wt), int(cap)] \
+ f_vals \
+ [df["n_shared"].sum() / df["n_pickups"].sum()]
counter += 1
except IOError:
pass
return data
def get_avg_dataframe():
cols = ["predictions", "vehicles", "waiting_time", "capacity"] + fields \
+ ["n_shared_per_passenger"]
data = pd.DataFrame(columns=cols)
counter = 0
gen = product(predictions, vehicles, caps, waiting_times)
for (p, v, cap, wt) in gen:
f_vals = list()
try:
df = get_metrics(v, cap, wt, p)
for field in fields:
f_vals.append(np.mean(df[field]))
data.loc[counter] = [p, int(v), int(wt), int(cap)] \
+ f_vals \
+ [df["n_shared"].sum() / df["n_pickups"].sum()]
counter += 1
except IOError:
pass
return data
def make_ts_area_plot_single(vecs, cap, wt, rb, weekday):
# sns.set_context("poster", font_scale=2)
plt.figure()
df = get_metrics(vecs, cap, wt, rb)
subfields = [
"empty_waiting", "empty_rebalancing", "empty_moving_to_pickup"
]
subfields.extend(["time_pass_%d" % i for i in xrange(1, cap + 1)])
df_small = df[subfields].copy()
q_str = "{0} * 2878 <= index <= ({0} + 1) * 2878".format(weekday)
df_small = df_small.query(q_str)
df_small.index = range(2879)
ax = df_small.plot(kind="area", colormap="rainbow", figsize=(4, 2.2))
labels = ["Waiting", "Rebalancing", "Picking Up"]
labels.extend(["N. Pass: %d" % n for n in xrange(1, cap + 1)])
handles, _ = ax.get_legend_handles_labels()
handles = fix_area_handles(handles)
lgd = ax.legend(reversed(handles),
reversed(labels),
loc='center left',
bbox_to_anchor=(1.0, 0.5),
borderaxespad=0,
handletextpad=0)
d_str = "N. Vecs: {}, Cap: {}, M.W.T: {}".format(vecs, cap, wt)
t_str = "Vehicle Occupancy Over Time On {} \n w/ ".format(days[weekday])
ax.set_title(t_str + d_str)
max_x_ticks = ax.get_xticks()[-1]
ax.set_xticks(np.arange(0, max_x_ticks, max_x_ticks / 6))
dr = pd.date_range(start="05-05-16",
periods=len(ax.get_xticks()),
freq="4H")
dr = dr.map(lambda t: t.strftime("%H"))
ax.set_xticklabels(dr)
vals = ax.get_yticks()
ax.set_yticklabels(
['{:3.0f}%'.format((x / 10) / (vecs / 1000)) for x in vals])
ax.set_xlabel("Hour")
plt.savefig("figs/ts-area-v{}-c{}-w{}-{}.png".format(
vecs, cap, wt, days[weekday]),
bbox_extra_artists=(lgd, ),
bbox_inches='tight')
plt.close()
def make_ts_area_plot_single(vecs, cap, wt, rb, weekday):
# sns.set_context("poster", font_scale=2)
plt.figure()
df = get_metrics(vecs, cap, wt, rb)
subfields = ["empty_waiting", "empty_rebalancing",
"empty_moving_to_pickup"]
subfields.extend(["time_pass_%d" % i for i in xrange(1, cap + 1)])
df_small = df[subfields].copy()
q_str = "{0} * 2878 <= index <= ({0} + 1) * 2878".format(weekday)
df_small = df_small.query(q_str)
df_small.index = range(2879)
ax = df_small.plot(kind="area", colormap="rainbow",
figsize=(4, 2.2))
labels = ["Waiting", "Rebalancing", "Picking Up"]
labels.extend(["N. Pass: %d" % n for n in xrange(1, cap + 1)])
handles, _ = ax.get_legend_handles_labels()
handles = fix_area_handles(handles)
lgd = ax.legend(reversed(handles),
reversed(labels),
loc='center left',
bbox_to_anchor=(1.0, 0.5),
borderaxespad=0,
handletextpad=0)
d_str = "N. Vecs: {}, Cap: {}, M.W.T: {}".format(vecs, cap, wt)
t_str = "Vehicle Occupancy Over Time On {} \n w/ ".format(days[weekday])
ax.set_title(t_str + d_str)
max_x_ticks = ax.get_xticks()[-1]
ax.set_xticks(np.arange(0, max_x_ticks, max_x_ticks / 6))
dr = pd.date_range(start="05-05-16", periods=len(ax.get_xticks()),
freq="4H")
dr = dr.map(lambda t: t.strftime("%H"))
ax.set_xticklabels(dr)
vals = ax.get_yticks()
ax.set_yticklabels(['{:3.0f}%'.format((x / 10) / (vecs / 1000))
for x in vals])
ax.set_xlabel("Hour")
plt.savefig(
"figs/ts-area-v{}-c{}-w{}-{}.png".format(vecs, cap, wt, days[weekday]),
bbox_extra_artists=(lgd,), bbox_inches='tight')
plt.close()
def make_ts_plot(vecs, wt, rb, field):
# fmt = DateFormatter("%a")
# matplotlib.rc("font", weight="bold")
# matplotlib.rc("axes", labelweight="bold")
# matplotlib.rc("figure", titleweight="bold")
fig, ax = plt.subplots()
fig.set_size_inches(4, 2.46)
for cap, clr in zip(caps, clrs):
df = get_metrics(vecs, cap, wt, 0)
locs, labels = plt.xticks()
_, dts = plot_ts(df, field, "o", color=clr, alpha=1,
label=str(cap), markersize=4)
ticks = [min(dts)] + list(ax.get_xticks()) + [max(dts)]
new_ticks = list()
for i in xrange(len(ticks) - 1):
new_ticks.append(ticks[i])
new_ticks.append(0.5 * (ticks[i] + ticks[i + 1]))
new_ticks.append(ticks[-1])
ax.set_xticks(new_ticks)
ticklabels = "| Su | Mo | Tu | We | Th | Fr | Sa |".split(" ")
ax.set_xticklabels(ticklabels)
lgd = plt.legend(loc="center left", fancybox=True,
shadow=True, bbox_to_anchor=(1, 0.5),
title="Capacity")
lgd.get_title().set_fontsize(15)
set_legend_marker_size(lgd, 15)
plt.ylabel(prettify(field))
if "%" in prettify(field):
ax.set_ylim([0, 1])
vals = ax.get_yticks()
ax.set_yticklabels(['{:3.0f}%'.format(x * 100) for x in vals])
# fig.autofmt_xdate()
# plt.title("N. Vecs: {}, M.W.T: {}".format(vecs, wt))
plt.savefig("figs/ts-{}-v{}-w{}.png".format(field, vecs, wt),
bbox_extra_artists=(lgd,), bbox_inches='tight')
plt.close()
import json
import sys
from typing import Any, List, Mapping, Tuple
from pydantic.tools import parse_obj_as
from common import MethodAbs, get_metrics
with open(sys.argv[1], "r") as f:
dump: Mapping[str, List[Tuple[str, Any]]] = json.load(f)
for method, abs_json in dump.items():
abstractions = parse_obj_as(MethodAbs, abs_json)
metrics = get_metrics(abstractions)
print("=====" * 20)
print("===== Method: " + method)
print(abstractions.body)
for stmt, details in abstractions.abstractions:
print(" > " + stmt)
print(" - Local:")
for k, v in details.localNodeMap.items():
print(f" - {k}: {v}")
print(" - Global:")
for k, v in details.globalNodeMap.items():
print(f" - {k}: {v}")
print(" - Node handlers:")
for nodeID, event, methods in details.nodeHandlerMap:
print(f" - {nodeID}, {event}: {methods}")
print(" - Dialog handlers:")
for nodeID, event, methods in details.dialogHandlerMap:
print(f" - {nodeID}, {event}: {methods}")
print()
import joblib
import numpy as np
import matplotlib.pyplot as plt
from common import load_firstlayer_data, get_metrics
from Graphics import make_confusion_matrix
Istlayer_dataset_path = "../../Datasets/API-Intent-Traffic/Other_CSVs/1st_Layer/"
test_samples, test_labels=load_firstlayer_data(Istlayer_dataset_path, data='Testing')
rf = joblib.load("./Results/Models/RFOptiStochastic3.joblib")
predictions= rf.predict(test_samples)
cm, accuracy, precision, recall, f1 = get_metrics(test_labels, predictions)
categories=['Benign', 'Malware']
labels = ['True Neg','False Pos','False Neg','True Pos']
make_confusion_matrix(cm,
group_names=labels,
categories=categories,
cmap='binary',
sklearn_matrix=True)
def draw_importance(rf, test_samples):
importances = rf.feature_importances_
std = np.std([tree.feature_importances_ for tree in rf.estimators_],
axis=0)
indices = np.argsort(importances)[::-1]
def create_k8s_host_app__k8s_applications(self):
if self.app_region is not None and 'glusterfs' in (
(self.region_data)['data']['features']['volume']['features']):
test_flag = True
ret_env = create_envs(self.app_k8s_env_file)
self.assert_successful(ret_env)
ret_volume = create_volume(self.app_k8s_gfs_volume, 'glusterfs',
None)
self.assert_successful(ret_volume)
volume_id = ret_volume['volume_id']
if settings.ENV == 'private':
yaml_content = "{}:\n alauda_lb: ALB\n net: host\n image: {}/{}:{}\n" \
"size: XXS\n ports:\n - '{}:80:80/http'\n number :1\n"\
"env_file: {}\n volumes\n - {}:/var/\n" \
.format(self.app_host_service_name, get_registry_info().get('registry_url', None),
settings.PRIVATE_REPO, settings.IMAGE_TAG,
self.haproxy, self.app_k8s_env_file, self.app_k8s_gfs_volume)
else:
# APP yaml支持host模式服务，添加环境变量文件，添加gfs的volume
yaml_content = "{}:\n alauda_lb: ALB\n ports:\n - '{}:81:81/http'\n" \
" image: {}/{}/hello-world:latest\n size: XXS\n net: host\n number: 1\n" \
" env_file: {}\n volumes:\n - {}:/var/\n" \
.format(self.app_host_service_name, self.haproxy, settings.REGISTRY_URL,
settings.CLAAS_NAMESPACE, self.app_k8s_env_file, self.app_k8s_gfs_volume)
print('yaml_content:{}'.format(yaml_content))
# self.create_app_action(self.app_k8s_name, yaml_content, self.app_region, 'ALB', self.haproxy, False)
# 创建应用 会判断应用的最终状态，如果不是Running 直接返回
ret1 = create_application(self.app_k8s_host_name,
files_data=yaml_content,
region=self.app_region)
self.assert_successful(ret1)
# 验证环境变量文件是否添加进去 失败可以继续后面测试
ret4 = exec_feature(self.app_host_service_name,
self.namespace,
command="env",
commands_string="key=value",
app_name=self.app_k8s_host_name)
if not ret4['success']:
test_flag = False
# 判断存储卷类型 不阻塞后面的测试
ret6 = verify_volumes(self.app_host_service_name, volume_id,
self.app_k8s_host_name)
if not ret6['success']:
test_flag = False
# 判断是否有Metrics 不阻塞后面的测试
ret7 = get_metrics(self.app_host_service_name,
self.app_k8s_host_name)
if not ret7['success']:
test_flag = False
# check 服务的日志
ret14 = get_logs(self.app_host_service_name,
app_name=self.app_k8s_host_name)
if not ret14['success']:
test_flag = False
# 删除应用
ret_delete = delete_application(self.app_k8s_host_name,
self.app_region)
self.assert_successful(ret_delete)
result = {
'success': test_flag,
"create envfile": ret_env,
"create gfs volume": ret_volume,
"create application": ret1,
"get service env": ret4,
"get service volume type": ret6,
"get service metrics": ret7,
"get service log": ret14,
"delete service": ret_delete
}
self.assert_successful(result)
return {"success": True, "total": "All success"}
else:
return {
"success": True,
"total": "there is no alb region, skip the case"
}
from pydantic.tools import parse_obj_as
from common import MethodAbs, get_metrics
with open(sys.argv[1], "r") as f:
dump1: Mapping[str, List[Tuple[str, Any]]] = json.load(f)
with open(sys.argv[2], "r") as f:
dump2: Mapping[str, List[Tuple[str, Any]]] = json.load(f)
for m in set(dump1.keys()).intersection(set(dump2.keys())):
m_printed = False
abs1 = dump1[m]
abs2 = dump2[m]
parsed1 = parse_obj_as(MethodAbs, abs1)
parsed2 = parse_obj_as(MethodAbs, abs2)
metrics1 = get_metrics(parsed1)
metrics2 = get_metrics(parsed2)
# assert len(metrics1) == len(metrics2)
if len(metrics1) != len(metrics2):
continue
if metrics1 != metrics2:
for s1, s2 in zip(metrics1, metrics2):
unit = s1["unit"]
# assert s1["unit"] == s2["unit"]
if s1["unit"] != s2["unit"]:
continue
for k in s1["metrics"].keys():
m1 = s1["metrics"][k]
m2 = s2["metrics"][k]
if m1 != m2:
print("- %s: %s != %s" % (k, m1, m2))
def create_and_evaluate_RF(dic):
rf = RandomForestClassifier(**dic, n_jobs=n_jobs)
rf.fit(train_samples, train_labels)
predictions = rf.predict(test_samples)
_, _, _, f1 = get_metrics(test_labels, predictions, get_cm=False)
return {'loss': 1 - f1, 'status': STATUS_OK}
def create_k8s_flannel_app__k8s_applications(self):
''' create app with most alauda yaml features: environment|links|net|number|size|
volumes|alauda_lb|amount_points|labels'''
if self.app_region is not None:
test_flag = True
ret1 = create_configuration(self.k8s_app_config, "value",
self.k8s_app_config_key)
self.assert_successful(ret1)
if settings.ENV == 'private':
yaml_content = "{}:\n alauda_lb: ALB\n net: flannel\n image: {}/{}:{}\n number: 1\n" \
"size: XXS\n ports:\n - '{}:80:80/http'\n" \
" environment:\n - k8s_key=k8s-value\n - __ALAUDA_FILE_LOG_PATH__=/home/*.txt\n" \
" volumes:\n - /home/:/var/\n mount_points:\n - path: /home/abc\n config: {}/{}\n" \
" labels:\n - 'constraint:node==ip:{}'" \
.format(self.app_flannel_service_name, get_registry_info().get('registry_url', None),
settings.PRIVATE_REPO, settings.IMAGE_TAG, self.haproxy,
self.k8s_app_config, self.k8s_app_config_key, self.k8s_ip_tag
)
else:
# APP yaml支持flannel模式服务，添加环境变量，添加配置文件，添加local的volume，指定日志文件，部署在指定的机器上
yaml_content = "{}:\n alauda_lb: ALB\n ports:\n - '{}:80:80/http'\n" \
" image: {}/{}/hello-world:latest\n size: XXS\n net: flannel\n number: 1\n" \
" environment:\n - k8s_key=k8s-value\n - __ALAUDA_FILE_LOG_PATH__=/home/*.txt\n"\
" volumes:\n - /home/:/var/\n mount_points:\n - path: /home/abc\n config: {}/{}\n"\
" labels:\n - 'constraint:node==ip:{}'"\
.format(self.app_flannel_service_name, self.haproxy, settings.REGISTRY_URL,
settings.CLAAS_NAMESPACE, self.k8s_app_config, self.k8s_app_config_key, self.k8s_ip_tag)
print('yaml_content:{}'.format(yaml_content))
# self.create_app_action(self.app_k8s_name, yaml_content, self.app_region, 'ALB', self.haproxy, False)
#创建应用 会判断应用的最终状态，如果不是Running 直接返回
ret1 = create_application(self.app_k8s_name,
files_data=yaml_content,
region=self.app_region)
self.assert_successful(ret1)
# 验证应用内的服务是否可以访问，失败不影响后续操作
ret_access_service = access_service(self.app_flannel_service_name,
self.haproxy,
self.app_k8s_name)
if not ret_access_service['success']:
test_flag = False
# 检查应用创建成功后yaml,失败后返回，因为会影响更新
ret2 = get_yaml(self.app_k8s_name)
if ret2['status'] != 200:
test_flag = False
ret2 = {
"success":
False,
"message":
"get application yaml failed, jakiro api error code {}, error:{}"
.format(ret2["status"], ret2["text"])
}
elif self.app_flannel_service_name not in ret2['text']:
test_flag = False
ret2 = {
"success":
False,
"message":
"service_name is {},not in yaml:{}".format(
self.app_flannel_service_name, ret2['text'])
}
else:
update_yaml = ret2['text'].replace("XXS", "XS")
ret2 = {"success": True, "total": ret2["total"]}
self.assert_successful(ret2)
# 检查应用的compose-yaml 失败后不影响后续操作
ret3 = get_compose_yaml(self.app_k8s_name)
if ret3['status'] != 200:
test_flag = False
ret3 = {
"success":
False,
"message":
"get application compose yaml failed, jakiro api error code {},error:{}"
.format(ret3['status'], ret3['text'])
}
elif self.app_flannel_service_name not in ret3['text']:
test_flag = False
ret3 = {
"success":
False,
"message":
"service_name is {},not in yaml:{}".format(
self.app_flannel_service_name, ret3['text'])
}
else:
ret3 = {"success": True, "total": ret3["total"]}
# 验证环境变量是否添加进去 失败可以继续后面测试
ret4 = exec_feature(self.app_flannel_service_name,
self.namespace,
command="env",
commands_string="k8s_key=k8s-value",
app_name=self.app_k8s_name)
if not ret4['success']:
test_flag = False
# 验证配置文件是否添加进去 失败可以继续后面测试
ret5 = exec_feature(self.app_flannel_service_name,
self.namespace,
command="'cat /home/abc'",
commands_string="value",
app_name=self.app_k8s_name)
if not ret5['success']:
test_flag = False
# 判断存储卷类型 不阻塞后面的测试
ret6 = verify_volumes(self.app_flannel_service_name, "host_path",
self.app_k8s_name)
if not ret6['success']:
test_flag = False
# 判断是否有Metrics 不阻塞后面的测试
ret7 = get_metrics(self.app_flannel_service_name,
self.app_k8s_name)
if not ret7['success']:
test_flag = False
ret_stop = stop_application(self.app_k8s_name, self.app_region)
self.assert_successful(ret_stop)
ret_start = start_application(self.app_k8s_name, self.app_region)
self.assert_successful(ret_start)
#验证更新操作，失败直接返回
ret_update = update_application(self.app_k8s_name,
files_data=update_yaml,
region=self.app_region)
self.assert_successful(ret_update)
# check 服务的日志
ret14 = get_logs(self.app_flannel_service_name,
app_name=self.app_k8s_name)
if not ret14['success']:
test_flag = False
# check 日志文件
ret15 = get_logfile(self.app_flannel_service_name,
self.app_k8s_name)
if not ret15['success']:
test_flag = False
#删除应用
ret_delete = delete_application(self.app_k8s_name, self.app_region)
self.assert_successful(ret_delete)
result = {
'success': test_flag,
"create application": ret1,
"access sercie ": ret_access_service,
"get yaml": ret2,
"get compose yaml": ret3,
"get service env": ret4,
"get service config": ret5,
"get service volume type": ret6,
"get service metrics": ret7,
"stop application": ret_stop,
"start application": ret_start,
"update application": ret_update,
"get service log": ret14,
"get service logfile": ret15,
"delete service": ret_delete
}
self.assert_successful(result)
return {"success": True, "total": "All success"}
else:
return {
"success": True,
"total": "there is no alb region, skip the case"
}
def k8s_host__k8s_service(self):
if self.haproxy:
#设置flag
test_flag = True
#创建部署服务需要的环境变量文件 创建失败就直接返回
ret1 = create_envs(self.k8s_envfile)
self.assert_successful(ret1)
#创建部署服务需要的glustfs存储卷，创建失败直接返回
ret2 = create_volume(self.gluster_name, 'glusterfs', None)
self.assert_successful(ret2)
#获取当前所在集群的Haproxy信息，获取失败直接返回
ret3 = get_haproxy(self.haproxy)
self.assert_successful(ret3)
#获取创建服务需要的数据
k8sFlannelData = data.ServiceData(self.k8s_host_service,
self.namespace,
settings.SERVICE_CLAAS_REGION[0],
lb_type='haproxy',
alb_name=self.haproxy,
lb_id=ret3['haproxy_id'],
volume_id=ret2['volume_id'],
volume_name=self.gluster_name,
envfile=self.k8s_envfile)
#创建Host模式挂载环境变量文件和glustfs存储卷的服务
ret4 = create_service(self.k8s_host_service,
k8sFlannelData.k8s_host_service(),
settings.SERVICE_CLAAS_REGION[0])
if not ret4["success"]:
delete_volume(ret2['volume_id'], self.gluster_name)
self.assert_successful(ret4)
#访问服务，及时失败也可以继续执行测试
ret5 = access_service(self.k8s_host_service, self.haproxy)
if not ret5['success']:
test_flag = False
# 验证环境变量是否添加进去 失败可以继续后面测试
ret6 = exec_feature(self.k8s_host_service,
self.namespace,
command="env",
commands_string="key=value")
if not ret6['success']:
test_flag = False
# 验证volume id是否一致
ret7 = verify_volumes(self.k8s_host_service, ret2['volume_id'])
if not ret7['success']:
test_flag = False
# 判断是否有Metrics 不阻塞后面的测试
ret8 = get_metrics(self.k8s_host_service)
if not ret8['success']:
test_flag = False
# 停止服务 如果失败block后面操作
ret9 = stop_app(self.k8s_host_service)
self.assert_successful(ret9)
# 启动服务 如果失败block 后面操作
ret10 = start_app(self.k8s_host_service, num=1)
self.assert_successful(ret10)
# scale up 服务，更新服务的数量和size，失败block后面操作
ret11 = update_service(self.k8s_host_service, num=2, size="XS")
self.assert_successful(ret11)
# scale down 服务更新服务的数量和size 失败block后面操作
ret12 = update_service(self.k8s_host_service, num=1, size="XXS")
self.assert_successful(ret12)
# check 服务的日志
ret13 = get_logs(self.k8s_host_service)
if not ret13['success']:
test_flag = False
ret14 = delete_app(self.k8s_host_service,
settings.SERVICE_CLAAS_REGION[0])
if not ret14['success']:
test_flag = False
#删除volume
sleep(30)
delete_volume(ret2['volume_id'], self.gluster_name)
result = {
'success': test_flag,
"create envfile ": ret1,
"create glustfs volume": ret2,
"get haproxy id ": ret3,
"create service": ret4,
"access service": ret5,
"check envfile": ret6,
"check volume": ret7,
"check metrics": ret8,
"stop service": ret9,
"start service": ret10,
"scale up": ret11,
"scale down": ret12,
"check log": ret13,
"delete service": ret14
}
self.assert_successful(result)
return result
def max_features_optimisation(
train_samples,
train_labels,
test_samples,
test_labels,
values=None,
verbose=False,
graph=True,
save=True,
metric='f1',
max_depth=1000,
min_samples_split=2,
max_leaf_nodes=None,
min_samples_leaf=1,
n_estimators=100,
):
if values == None:
values = np.asarray(
[2, *range(100, len(train_samples.columns), 150), None])
metrics = pd.DataFrame(columns=['accuracy', 'precision', 'recall', 'f1'])
index = values
for max_feature in values:
rf_max_features = RandomForestClassifier(
min_samples_split=min_samples_split,
max_depth=max_depth,
min_samples_leaf=min_samples_leaf,
max_leaf_nodes=max_leaf_nodes,
n_estimators=n_estimators,
max_features=max_feature)
if verbose:
print(
'Optimisation du max_features : Entrainement pour max_features = ',
max_feature)
rf_max_features.fit(train_samples, train_labels)
predictions_max_features = rf_max_features.predict(test_samples)
arr = np.asarray(
get_metrics(test_labels, predictions_max_features, get_cm=False))
if np.isnan(arr).any():
if verbose:
print('Il y a eu une erreur pour cette valeur de max_features')
index = np.delete(index, np.where(index == max_feature))
else:
metrics = metrics.append(pd.DataFrame(arr.reshape(1, -1),
columns=list(metrics)),
ignore_index=True)
if verbose:
print(f"max_features = {max_feature} ; " + metric +
f" = {metrics.at[len(metrics)-1, metric]}")
metrics = metrics.set_index(index)
if save:
metrics.to_csv('./Results/Optimisation/max_feature_optimisation.csv',
index=True)
if verbose:
print("Résultats intermédiaires de l'optimisation sauvegardés")
X = np.asarray(metrics.index)
Y = metrics[metric].to_numpy()
i = np.argmax(Y)
if verbose:
print(
f'Le maximum pour {metric} est de {Y[i]} et est atteint pour max_features={X[i]}'
)
if graph:
fig, ax = plt.subplots(1)
ax.plot(X, Y, 'r--')
ax.set_ylabel(metric)
ax.set_xlabel('max_features')
ax.set_title(metric + ' in fonction of max_features')
if i < len(X) - 1:
ax.annotate(
'local max',
xy=(X[i], Y[i]),
xytext=(X[i + 1], Y[i + 1]),
arrowprops=dict(facecolor='black', shrink=0.05),
)
else:
ax.annotate(
'local max',
xy=(X[i], Y[i]),
xytext=(X[i - 1], Y[i - 1]),
arrowprops=dict(facecolor='black', shrink=0.05),
)
fig.show
else:
title = metric + ' in fonction of max_features'
return title, [X, Y], X[i]
return X[i]
def inner_elb_service_test__k8s_service(self):
test_flag = True
# 创建一个内网的ELB 失败返回
ret1 = create_alb(self.k8s_internal_elb,
create_type='manual',
type='elb',
alb_region=settings.SERVICE_CLAAS_REGION[0],
address_type="internal")
self.assert_successful(ret1)
elb_data = data.ServiceData(self.k8s_innerelb_service,
settings.CLAAS_NAMESPACE,
settings.SERVICE_CLAAS_REGION[0],
lb_type='elb',
alb_name=self.k8s_internal_elb,
lb_id=ret1['id'])
# 创建一个使用ELB网络模式的服务 失败返回
ret2 = create_service(self.k8s_innerelb_service,
elb_data.k8s_innerelb_service(),
settings.SERVICE_CLAAS_REGION[0])
self.assert_successful(ret2)
# 验证服务是否可以访问 失败继续测试
ret3 = access_service(self.k8s_innerelb_service, self.k8s_internal_elb)
if not ret3['success']:
test_flag = False
# 验证环境变量是否添加进去 失败可以继续后面测试
ret4 = exec_feature(self.k8s_innerelb_service,
self.namespace,
command="'/bin/ls /'")
if not ret4['success']:
test_flag = False
# 判断是否有Metrics 不阻塞后面的测试
ret5 = get_metrics(self.k8s_innerelb_service)
if not ret5['success']:
test_flag = False
# 停止服务 如果失败block后面操作
ret6 = stop_app(self.k8s_innerelb_service)
self.assert_successful(ret6)
# 启动服务 如果失败block 后面操作
ret7 = start_app(self.k8s_innerelb_service, num=1)
self.assert_successful(ret7)
# scale up 服务，更新服务的数量和size，失败block后面操作
ret8 = update_service(self.k8s_innerelb_service, num=2, size="XS")
self.assert_successful(ret8)
# scale down 服务更新服务的数量和size 失败block后面操作
ret9 = update_service(self.k8s_innerelb_service, num=1, size="XXS")
self.assert_successful(ret9)
# check 服务的日志
# ret10 = get_logs(self.k8s_innerelb_service)
# if not ret10['success']:
# test_flag = False
ret11 = delete_alb(self.k8s_innerelb_service)
self.assert_successful(ret11)
ret12 = delete_app(self.k8s_innerelb_service)
self.assert_successful(ret12)
result = {
'success': test_flag,
"create elb": ret1,
"create elb service": ret2,
"access service": ret3,
"service exec ": ret4,
"get metrics": ret5,
"stop service": ret6,
"start service": ret7,
"scale up service": ret8,
"scale down service": ret9,
# "get logs": ret10,
"delete elb": ret11,
"delete service": ret12
}
self.assert_successful(result)
return result
def k8s_flannel__k8s_service(self):
# 创建flannel服务支持:环境变量，配置文件，local volume，日志文件，部署到指定机器
if self.haproxy:
test_flag = True
ret1 = get_haproxy(self.haproxy)
self.assert_successful(ret1)
k8sFlannelData = data.ServiceData(
self.k8s_flannel_service,
self.namespace,
settings.SERVICE_CLAAS_REGION[0],
lb_type='haproxy',
alb_name=self.haproxy,
lb_id=ret1['haproxy_id'],
node_tag=self.node_tag.split(":")[1],
mipn_enabled=True)
#创建服务支持 环境变量 local volume，配置文件，指定日志文件，部署在指定的机器上 block后面操作
ret2 = create_service(self.k8s_flannel_service,
k8sFlannelData.k8s_flannel_service(),
settings.SERVICE_CLAAS_REGION[0])
self.assert_successful(ret2)
#验证服务是否可以访问 失败可以继续后面测试
ret3 = access_service(self.k8s_flannel_service, self.haproxy)
if not ret3['success']:
test_flag = False
#验证环境变量是否添加进去 失败可以继续后面测试
ret4 = exec_feature(self.k8s_flannel_service,
self.namespace,
command="env",
commands_string="k8s_key=k8s_value")
if not ret4['success']:
test_flag = False
#验证配置文件是否添加进去 失败可以继续后面测试
ret5 = exec_feature(self.k8s_flannel_service,
self.namespace,
command="'cat /home/abc'",
commands_string="config")
if not ret5['success']:
test_flag = False
#判断存储卷类型 不阻塞后面的测试
ret6 = verify_volumes(self.k8s_flannel_service, "host_path")
if not ret6['success']:
test_flag = False
#判断是否有Metrics 不阻塞后面的测试
ret7 = get_metrics(self.k8s_flannel_service)
if not ret7['success']:
test_flag = False
# 停止服务 如果失败block后面操作
ret8 = stop_app(self.k8s_flannel_service)
self.assert_successful(ret8)
#启动服务 如果失败block 后面操作
ret9 = start_app(self.k8s_flannel_service, num=1)
self.assert_successful(ret9)
#scale up 服务，更新服务的数量和size，失败block后面操作
ret10 = update_service(self.k8s_flannel_service, num=2, size="XS")
self.assert_successful(ret10)
#check 所有的容器都部署在指定的机器上 不阻塞后面的测试
ret11 = check_node(self.k8s_flannel_service, self.node_tag)
if not ret11['success']:
test_flag = False
# scale down 服务更新服务的数量和size 失败block后面操作
ret12 = update_service(self.k8s_flannel_service, num=1, size="XXS")
self.assert_successful(ret12)
# check 所有的容器都部署在指定的机器上 不阻塞后面的测试
ret13 = check_node(self.k8s_flannel_service, self.node_tag)
if not ret13['success']:
test_flag = False
# check 服务的日志
ret14 = get_logs(self.k8s_flannel_service)
if not ret14['success']:
test_flag = False
#check 日志文件
ret15 = get_logfile(self.k8s_flannel_service)
if not ret15['success']:
test_flag = False
#删除服务
ret16 = delete_app(self.k8s_flannel_service,
settings.SERVICE_CLAAS_REGION[0])
if not ret16['success']:
test_flag = False
result = {
'success': test_flag,
"get haproxy id ": ret1,
"create k8s haproxy service": ret2,
"access sercie ": ret3,
"get service env": ret4,
"get servie config": ret5,
"get service volume type": ret6,
"get service metrics": ret7,
"stop service": ret8,
"start service": ret9,
"scale up service": ret10,
"check instance in node": ret11,
"scale down service": ret12,
"check instance in node": ret13,
"get service log": ret14,
"get service logfile": ret15,
"delete service": ret16
}
self.assert_successful(result)
return result
plt.plot(epochs, loss, 'bo', label='Training loss')
plt.plot(epochs, val_loss, 'r', label='Validation loss')
plt.title('Training and validation loss')
plt.legend()
plt.show()
test_samples, test_labels = get_test_data(
test, static_df, dic, Snd_layer_data_path) #Création des données de test
static_prediction = [u[0][70] for u in test_samples
] #Extraction de la premiere prédiction statique
static_prediction = np.round(
np.asarray(static_prediction)) #Transormation en label prédit
hybrid_prediction = model.predict(test_samples) #Prédiction hybride
hybrid_prediction = Binary_Classification(
hybrid_prediction
) #Transormation de la prédiction multiclasse en prédiction binaire
test_labels = Binary_Classification(
test_labels) #Transformation du label multiclasse en label binaire
print(get_metrics(
test_labels, static_prediction,
get_cm=True)) #Matrice de confusioon du premier modele statique
print(get_metrics(test_labels, hybrid_prediction,
get_cm=True)) #Matrice de confusion du modèle hybride
