def predict_vm(ecsDataPath, inputFilePath, resultFilePath, k, threshold):
# Do your work from here#
all_hat = []
all_hat_name = []
pre_dic = {}
#徐劲夫，将源文件转化为列表,dataMat = [1,2,3,4,.....] 按时间序列排序，labelMat = [] #对应申请量
guige, flavor_name, cpu_mem, label_Mat, test_time = read_inputfile(
ecsDataPath, inputFilePath, threshold)
#要申请的是CPU OR MEM
if cpu_mem == "CPU":
zero_one = 0
elif cpu_mem == "MEM":
zero_one = 1
else:
raise ("memory_alloction_name must be CPU OR MEM")
dateMat = [i for i, _ in enumerate(label_Mat[0])]
testMat = [i + len(dateMat) for i in range(test_time)]
for index, f_n in enumerate(flavor_name):
flavor = flavor_name.values()[index]
flavor_cpu_or_mem = int(
flavor[zero_one] if not zero_one else flavor[zero_one] / 1024)
labelMat = label_Mat[index]
yhat = create_result(testMat, dateMat, labelMat, k) # 每一预测种类返回一个预测序列
pre = yhat[-1] - labelMat[-1] #计算预测 申请了多少台虚拟机
#将Yhat 传入memory_alloction 进行内存分配
all_hat.extend([flavor_cpu_or_mem] * pre)
all_hat_name.extend([f_n] * pre)
pre_dic[f_n] = pre #{"flavor" :pre,....}
result = get_memory_allocation(guige[zero_one], all_hat, all_hat_name)
all_flavor = len(all_hat) #预测虚拟机总数
need_xuniji_num = len(result)
output_writer(all_flavor, pre_dic, result, need_xuniji_num, resultFilePath)
'''
def predict_vm(ecsDataPath, inputFilePath,resultFilePath,dict_k,threshold):
# Do your work from here#
all_hat =[]
all_hat_name = []
all_hat_limit = []
pre_dic={}
flavor_num_less_8 = []
select_pre_func_thread1 = 10 #选择不同函数的阈值
select_pre_func_thread2 = 25
#徐劲夫，将源文件转化为列表,dataMat = [1,2,3,4,.....] 按时间序列排序，labelMat = [] #对应申请量
guige, flavor_name, cpu_mem, label_Mat,test_time,start_weekday,start_test_weekday = read_inputfile(ecsDataPath, inputFilePath,threshold )
#要申请的是CPU OR MEM
if cpu_mem =="CPU":
zero_one = 0
elif cpu_mem =="MEM":
zero_one = 1
else:
raise ("memory_alloction_name must be CPU OR MEM")
# for index,f_n in enumerate(flavor_name):
# flavor = flavor_name.values()[index]
# flavor_cpu_or_mem = int(flavor[zero_one] if not zero_one else flavor[zero_one] /1024)
# labelMat = label_Mat[index]
#
#
# yhat = create_result(testMat,dateMat,labelMat,k)# 每一预测种类返回一个预测序列
# pre = yhat[-1] - labelMat[-1] #计算预测 申请了多少台虚拟机
# #将Yhat 传入memory_alloction 进行内存分配
# all_hat.extend( [flavor_cpu_or_mem]* pre)
# all_hat_name.extend([f_n]*pre)
# pre_dic[f_n] = pre #{"flavor" :pre,....}
# result = get_memory_allocation(guige[zero_one], all_hat, all_hat_name)
for index, f_n in enumerate(flavor_name):
flavor = flavor_name.values()[index]
flavor_cpu_or_mem = int(flavor[zero_one] if not zero_one else flavor[zero_one] / 1024)
flavor_cpu_or_mem_limit = int(flavor[1 - zero_one] if zero_one else flavor[1-zero_one] / 1024)
labelMat = label_Mat[index]
dateMat = [i for i, _ in enumerate(label_Mat[index])]
testMat = [i + len(dateMat) for i in range(test_time)]
##################################################################################################################################
k = dict_k[str(f_n)]
'''
下面几行是使用局部加权线性回归进行预测
'''
# yhat = create_result(testMat, dateMat, labelMat, k) # 每一预测种类返回一个预测序列
'''
下面两行，第一行是进行累积量预测，出现bug，第二行是预测单日申请量
修改是累积量，还是单日申请量，在inputdata.py文件63-67行
'''
# pre = yhat[-1] - labelMat[-len(yhat)-1] # 计算预测 申请了多少台虚拟机 # 预测的是累计量
# pre = sum(yhat) # 预测当日申请量
# if pre <= 0: pre = 2
##################################################################################################
'''
下面两行是使用均值大法进行预测，这里必须使用累积量进行预测
# n = labelMat[:]
# index = labelMat.index(0, 1)
# for j in range(index, len(labelMat)):
# n[j] = sum(labelMat[:j + 1])
#
'''
yhat = easy_pre(labelMat, test_time)
pre = int(yhat)
# if sum(labelMat[-test_time:]) <= select_pre_func_thread1 or sum(
# labelMat[-test_time:]) > select_pre_func_thread2:
# else:
# '''
# Markov 进行预测,不累加
# '''
# pre = Markov(labelMat,test_time)
'''
使用对应的星期进行预测,按单日量进行预测
'''
# pre = week_day_pre(start_weekday, labelMat, start_test_weekday, test_time)
'''
局部加权线性回归@ 累积量
# n = labelMat[:]
# for j in range(len(labelMat)):
# n[j] = sum(labelMat[:j + 1])
'''
# yhat = lwlrTest(testMat,dateMat,labelMat,k)
# pre = int((yhat[-1]- yhat[0]))
print(f_n)
'''
指数平滑
# n = labelMat[:]
# for j in range(len(labelMat)):
# n[j] = sum(labelMat[:j + 1])
'''
# a = 0.3
# yhat = zsph(labelMat,test_time,a)
# pre = int((yhat[-1]- yhat[0]))
# print("pre",pre)
'''
指数平滑_
'''
# pre = zsph_(labelMat,test_time,alpha = 0.6)
# print("pre",pre)
'''
GM11
'''
# pre = yuce(test_time,labelMat)
# print("pre",pre)
'''
画图
'''
# Draw(yhat, dateMat, n)
# 将Yhat 传入memory_alloction 进行内存分配
if pre !=0 :#pre != 0
all_hat.extend([flavor_cpu_or_mem] * pre)
all_hat_limit.extend([flavor_cpu_or_mem_limit] * pre)
all_hat_name.extend([f_n] * pre)
if int(f_n[6:]) < 8:
flavor_num_less_8.append(f_n)
pre_dic[f_n] = pre # {"flavor" :pre,....}
print("ssssss",list(sorted(pre_dic.items(),key = lambda x:x[0])))
result, delet, liyonglv = get_memory_allocation(zero_one, guige[zero_one], guige[1 - zero_one], all_hat,
all_hat_limit, all_hat_name)
print(liyonglv)
'''
对小于8的机型加个值，让分配率最大
'''
list_add_pre_less_8 = [0] * len(flavor_num_less_8)
best_list_add_pre_less_8 = list_add_pre_less_8[:]
print(len(flavor_num_less_8))
best_liyonglv = 0
best_result = []
orig_all_hat = all_hat[:]
orig_all_hat_limit = all_hat_limit[:]
orig_all_hat_name = all_hat_name[:]
orig_pre_dic = pre_dic.copy()
for i in range(4**len(flavor_num_less_8)):
t =i
all_hat = orig_all_hat[:]
all_hat_limit = orig_all_hat_limit[:]
all_hat_name = orig_all_hat_name[:]
pre_dic = orig_pre_dic.copy()
for j in range(len(flavor_num_less_8)):
list_add_pre_less_8[j] = t % 4
t = t/4
for list_index,n in enumerate(list_add_pre_less_8):
pre_dic[flavor_num_less_8[list_index]] = pre_dic[flavor_num_less_8[list_index]] + n
flavor = flavor_name[flavor_num_less_8[list_index]]
flavor_cpu_or_mem = int(flavor[zero_one] if not zero_one else flavor[zero_one] / 1024)
flavor_cpu_or_mem_limit = int(flavor[1 - zero_one] if zero_one else flavor[1-zero_one] / 1024)
f_n =flavor_num_less_8[list_index]
if n !=0:
all_hat.extend([flavor_cpu_or_mem] * n)
all_hat_limit.extend([flavor_cpu_or_mem_limit] * n)
all_hat_name.extend([f_n] * n)
xunhuan_result,delet,xunhaun_liyonglv = get_memory_allocation(zero_one,guige[zero_one], guige[1 - zero_one], all_hat, all_hat_limit, all_hat_name)
print("liyonglv",xunhaun_liyonglv)
if xunhaun_liyonglv> best_liyonglv:
best_liyonglv = xunhaun_liyonglv
best_result = xunhuan_result[:]
best_pre = pre_dic.copy()
best_all_hat = all_hat[:]
best_list_add_pre_less_8 = list_add_pre_less_8[:]
# best_flavor_num_less_8 = flavor_num_less_8
print("best_liyonglv:",best_liyonglv)
# print("list_add_pre_less_8:",list_add_pre_less_8)
# print("pre_dic:",pre_dic)
if (best_liyonglv - liyonglv < 0.02) and sum(best_list_add_pre_less_8)<10:
best_result = result[:]
best_pre = orig_pre_dic.copy()
best_all_hat = orig_all_hat[:]
# result = tuihuo(zero_one, guige[zero_one], guige[1 - zero_one], all_hat, all_hat_limit, all_hat_name)
# for key,value in delet.items():
# pre_dic[key] = pre_dic[key] - value
all_flavor = len(best_all_hat) #预测虚拟机总数
need_xuniji_num = len(best_result)
output_writer(all_flavor,best_pre,best_result,need_xuniji_num,resultFilePath)
'''
def predict_vm(ecs_lines, input_lines):
# Do your work from here#
result = []
if ecs_lines is None:
print('ecs information is none')
return result
if input_lines is None:
print('input file information is none')
return result
#训练第一天的0点 预测第一天的0点
ecs_first_date_zero = ecs_lines[0].split(
"\t")[2].strip().split()[0] + " " + "00:00:00"
ecs_first_date_zero = time.strptime(ecs_first_date_zero,
"%Y-%m-%d %H:%M:%S")
input_first_date_zero = input_lines[-2].strip().split(
)[0] + " " + "00:00:00"
input_first_date_zero = time.strptime(input_first_date_zero,
"%Y-%m-%d %H:%M:%S")
kuadu_first_last_day = (time.mktime(input_first_date_zero) -
time.mktime(ecs_first_date_zero)) / nd
kuadu_first_last_day = int(kuadu_first_last_day)
#print(u"时间跨度为"+str(kuadu_first_last_day))
# 行数为虚拟机的规格 列数是天数
ecs_xunlian = []
for i in range(30):
t = []
for j in range(kuadu_first_last_day):
t.append(0)
ecs_xunlian.append(t)
for ecs_line in ecs_lines:
ecs_line = ecs_line.strip()
ecs_now_name = ecs_line.split("\t")[1]
ecs_now_no = int(ecs_now_name.replace("flavor", ""))
ecs_now_date = ecs_line.split("\t")[2]
ecs_now_date = time.strptime(ecs_now_date, "%Y-%m-%d %H:%M:%S")
#print(ecs_now_name+" "+str(ecs_now_no)+" "+str(ecs_now_date))
ecs_kuadu_first_now_day = (time.mktime(ecs_now_date) -
time.mktime(ecs_first_date_zero)) / nd
ecs_kuadu_first_now_day = int(ecs_kuadu_first_now_day)
ecs_xunlian[ecs_now_no][ecs_kuadu_first_now_day] = ecs_xunlian[
ecs_now_no][ecs_kuadu_first_now_day] + 1
'''
print(u"训练集中的数据")
print(len(ecs_xunlian))
print(len(ecs_xunlian[0]))
temp = pymatrix.matrix(ecs_xunlian)
print(temp)
'''
# 获得要预测的规格
input_num = int(input_lines[2].strip())
input_nos = []
for i in range(input_num):
input_line = input_lines[i + 3]
input_no = input_line.strip().split()[0].replace("flavor", "")
input_no = int(input_no)
input_nos.append(input_no)
train_data = fluth_data.quZao2(ecs_xunlian, input_nos)
'''
print(u"===去噪之后===")
for t in train_data:
print(t)
print(len(train_data))
print(len(train_data[0]))
print("==============")
'''
#预测的第一天 预测的最后一天
input_first_date = input_lines[-2].strip()
input_first_date = time.strptime(input_first_date, "%Y-%m-%d %H:%M:%S")
input_last_date = input_lines[-1].strip()
input_last_date = time.strptime(input_last_date, "%Y-%m-%d %H:%M:%S")
kuadu_first_last_day = (time.mktime(input_last_date) -
time.mktime(input_first_date)) / nd
kuadu_first_last_day = int(kuadu_first_last_day)
#print(u"时间跨度为："+str(kuadu_first_last_day))
# 对数据进行预处理
train_data = preprocess.pp(train_data, kuadu_first_last_day)
'''
print(u"===预处理之后之后===")
for t in train_data:
print(t)
print(len(train_data))
print(len(train_data[0]))
print("==============")
'''
mm = pymatrix.matrix(train_data)
mm = mm.transpose()
#print(u'===GM算法的输入值===')
print(mm)
#print(mm.colAt(5))
#print(mm.colAt(7))
res = GM11.yuce(2, mm)
#print(res)
# 获得要预测的规格
yuce_flvorname_flavornum_s = {}
input_num = int(input_lines[2].strip())
for i in range(input_num):
input_line = input_lines[i + 3]
input_line_name = input_line.split(" ")[0]
yuce_flvorname_flavornum_s[input_line_name] = int(round(res[i]))
print(yuce_flvorname_flavornum_s)
######################
# 开始装箱
#####################
# input文件中的物理机的规格
input_wuLiJi_cpu = int(input_lines[0].split(" ")[0])
input_wuLiJi_mem = int(input_lines[0].split(" ")[1])
#input文件中需要预测的虚拟机[("flavor1",12,1024),("flavor1",12,1024)]
input_xuNiJis = []
i = 3
while (i < 3 + int(input_lines[2].strip())):
input_now_flavor_name = input_lines[i].strip().split(" ")[0]
input_now_flavor_CPU = int(input_lines[i].strip().split(" ")[1])
input_now_flavor_MEM = int(input_lines[i].strip().split(" ")[2])
input_now_flavor = [
input_now_flavor_name, input_now_flavor_CPU, input_now_flavor_MEM
]
input_xuNiJis.append(input_now_flavor)
i = i + 1
input_xuNiJis.reverse()
cpus = []
mems = []
names = []
for input_xuNiJi in input_xuNiJis:
input_xuNiJi_name = input_xuNiJi[0]
input_xuNiJi_CPU = input_xuNiJi[1]
input_xuNiJi_MEM = input_xuNiJi[2] / 1024
nums = yuce_flvorname_flavornum_s[input_xuNiJi_name]
for i in range(nums):
cpus.append(input_xuNiJi_CPU)
mems.append(input_xuNiJi_MEM)
names.append(input_xuNiJi_name)
# 优化的维度
input_weidu = input_lines[3 + int(input_lines[2].strip()) + 1].strip()
if (input_weidu == "CPU"):
zx_wuLiJis, _ = memory_alloction.get_memory_allocation(
input_wuLiJi_cpu, input_wuLiJi_mem, cpus, mems, names)
elif (input_weidu == "MEM"):
zx_wuLiJis, _ = memory_alloction.get_memory_allocation(
input_wuLiJi_mem, input_wuLiJi_cpu, mems, cpus, names)
else:
print("出错了，别玩了")
print(zx_wuLiJis)
#开始输出结果
result = []
sum = 0
for input_xuNiJi in input_xuNiJis:
input_xuNiJi_name = input_xuNiJi[0]
input_xuNiJi_num = yuce_flvorname_flavornum_s.get(input_xuNiJi_name)
sum = sum + input_xuNiJi_num
result.append(input_xuNiJi_name + " " + str(input_xuNiJi_num))
result.insert(0, str(sum))
result.append("")
result.append(len(zx_wuLiJis))
print(result)
for i in range(0, len(zx_wuLiJis), 1):
zx_wuLiJi = zx_wuLiJis[i]
sss = str(i + 1)
temp = {}
for xuNiJi in zx_wuLiJi:
if (temp.has_key(xuNiJi)):
temp[xuNiJi] = temp[xuNiJi] + 1
else:
temp[xuNiJi] = 1
print(temp)
for name in temp:
sss = sss + " " + name + " " + str(temp[name])
print(sss)
result.append(sss.strip())
return result
def predict_vm(ecs_lines, input_lines):
# Do your work from here#
result = []
if ecs_lines is None:
#print ('ecs information is none')
return result
if input_lines is None:
#print ('input file information is none')
return result
#### 去掉所有的空行
ecs_lines_new = []
for ecs_line in ecs_lines:
if(ecs_line.strip()!=""):
ecs_lines_new.append(ecs_line)
input_lines_new = []
for input_line in input_lines:
if(input_line.strip()!=""):
input_lines_new.append(input_line)
# 获得要预测的规格
input_num = int(input_lines_new[1].strip())
#训练第一天的0点 预测第一天的0点
ecs_first_date_zero = ecs_lines_new[0].split("\t")[2].strip().split()[0]+" "+"00:00:00"
ecs_first_date_zero = time.strptime(ecs_first_date_zero, "%Y-%m-%d %H:%M:%S")
input_first_date_zero = input_lines_new[6+input_num].strip().split()[0]+" "+"00:00:00"
input_first_date_zero = time.strptime(input_first_date_zero, "%Y-%m-%d %H:%M:%S")
kuadu_first_last_day = (time.mktime(input_first_date_zero)-time.mktime(ecs_first_date_zero))/nd
kuadu_first_last_day = int(kuadu_first_last_day)
##print(u"时间跨度为"+str(kuadu_first_last_day))
# 行数为虚拟机的规格 列数是天数
ecs_xunlian = []
for i in range(30):
t = []
for j in range(kuadu_first_last_day):
t.append(0)
ecs_xunlian.append(t)
for ecs_line in ecs_lines_new:
ecs_line = ecs_line.strip()
ecs_now_name = ecs_line.split("\t")[1]
ecs_now_no = int(ecs_now_name.replace("flavor",""))
ecs_now_date = ecs_line.split("\t")[2]
ecs_now_date = time.strptime(ecs_now_date, "%Y-%m-%d %H:%M:%S")
#print(ecs_now_name+" "+str(ecs_now_no)+" "+str(ecs_now_date))
ecs_kuadu_first_now_day = (time.mktime(ecs_now_date)-time.mktime(ecs_first_date_zero))/nd
ecs_kuadu_first_now_day = int(ecs_kuadu_first_now_day)
ecs_xunlian[ecs_now_no][ecs_kuadu_first_now_day] = ecs_xunlian[ecs_now_no][ecs_kuadu_first_now_day] + 1
'''
print(u"训练集中的数据")
print(len(ecs_xunlian))
print(len(ecs_xunlian[0]))
temp = pymatrix.matrix(ecs_xunlian)
print(temp)
'''
# 获得要预测的规格
input_num = int(input_lines_new[1].strip())
input_nos = []
for i in range(input_num):
input_line = input_lines_new[i+2]
input_no = input_line.strip().split()[0].replace("flavor","")
input_no = int(input_no)
input_nos.append(input_no)
train_data = fluth_data.quZao2(ecs_xunlian,input_nos)
# 增加一列0
train_data = preprocess.pp2(train_data)
'''
print("======增加0之后=======")
for t in train_data:
print(t)
print(len(train_data))
print(len(train_data[0]))
'''
###########获得预测跨度####################
#预测的第一天 预测的最后一天
input_first_date = input_lines_new[-2].strip()
input_first_date = time.strptime(input_first_date, "%Y-%m-%d %H:%M:%S")
input_last_date = input_lines_new[-1].strip()
input_last_date = time.strptime(input_last_date, "%Y-%m-%d %H:%M:%S")
kuadu_first_last_day_2 = (time.mktime(input_last_date)-time.mktime(input_first_date))/nd
kuadu_first_last_day_2 = int(kuadu_first_last_day_2)
#print(u"预测时间跨度为："+str(kuadu_first_last_day_2))
###########################################
temp = math.ceil(kuadu_first_last_day_2/2.0)
#print("temp="+str(temp))
#分片
train_data = preprocess.pp(train_data,temp)
'''
print(u"========分片之后============")
for t in train_data:
print(t)
print(len(train_data))
print(len(train_data[0]))
'''
##########开始预测############################
yuce_flvorname_flavornum_s = {}
s1 = [0]*len(train_data[0])
s2 = [0]*len(train_data[0])
s3 = [0]*len(train_data[0])
alpha = [0.6]*30
for i in range(len(train_data)):
#print(u"====规格"+str(i+1)+"=======")
t = train_data[i]
s1[0] = t[1]
for j in range(1,len(s1),1):
s1[j] = alpha[i]*train_data[i][j]+(1-alpha[i])*s1[j-1]
s2[0] = s1[1]
for j in range(1,len(s2),1):
s2[j] = alpha[i]*s1[j]+(1-alpha[i])*s2[j-1]
s3[0] = s2[1]
for j in range(1,len(s3),1):
s3[j] = alpha[i]*s2[j]+(1-alpha[i])*s3[j-1]
#print("s1= "+str(s1))
#print("s2= "+str(s2))
#print("s3= "+str(s3))
a = 3.0 * s1[-1] - 3 * s2[-1] + s3[-1]
b = alpha[i]/(2.0*(1-alpha[i])**2) * ((6-5 * alpha[i])*s1[-1] - 2*(5 - 4 * alpha[i])*s2[-1] + (4 - 3 * alpha[i]) * s3[-1])
c = alpha[i]**2/(2*((1-alpha[i])**2)) * (s1[-1] - 2*s2[-1] + s3[-1])
#print("a= "+str(a))
#print("b= "+str(b))
#print("c= "+str(c))
yuce1 = a + b + c
yuce2 = (a + 2 * b + 4 * c) * ((temp-1)/temp)
yuce = yuce1 + yuce2
yuce = round(yuce)
if yuce < 0:
yuce = 0
#print(u"预测值为 "+str(yuce))
name = "flavor"+str(i+1)
yuce_flvorname_flavornum_s[name] = int(yuce)
###############获得虚拟机名和预测台数的对应####################
######################################################
###################获得names cpus mems这三个序列######################
cpus = []
mems = []
names = []
#input文件中需要预测的虚拟机[("flavor1",12,1024),("flavor1",12,1024)]
input_xuNiJis = []
i = 2
while(i<2 + input_num):
input_now_flavor_name = input_lines_new[i].strip().split(" ")[0]
input_now_flavor_CPU = int(input_lines_new[i].strip().split(" ")[1])
input_now_flavor_MEM = int(input_lines_new[i].strip().split(" ")[2])/1024
input_now_flavor = [input_now_flavor_name,input_now_flavor_CPU,input_now_flavor_MEM]
input_xuNiJis.append(input_now_flavor)
nums = yuce_flvorname_flavornum_s[input_now_flavor_name]
for j in range(nums):
names.append(input_now_flavor_name)
cpus.append(input_now_flavor_CPU)
mems.append(input_now_flavor_MEM)
i = i + 1
#print(names)
#print(mems)
#print(cpus)
################# 获得物理机的规格###############
input_wuLiJi_cpu = int(input_lines_new[0].split(" ")[0])
input_wuLiJi_mem = int(input_lines_new[0].split(" ")[1])
########################获得物理机的规格#########
##################### 优化的维度 装箱###########################
input_weidu = input_lines_new[-3].strip()
if(input_weidu=="CPU"):
zx_wuLiJis,_ = memory_alloction.get_memory_allocation(input_wuLiJi_cpu,input_wuLiJi_mem,cpus,mems,names)
elif(input_weidu=="MEM"):
zx_wuLiJis,_ = memory_alloction.get_memory_allocation(input_wuLiJi_mem,input_wuLiJi_cpu,mems,cpus,names)
else:
pass
#print("出错了，别玩了")
#print(zx_wuLiJis)
#开始输出结果
result=[]
sum_t = 0
for input_xuNiJi in input_xuNiJis:
input_xuNiJi_name = input_xuNiJi[0]
input_xuNiJi_num = yuce_flvorname_flavornum_s.get(input_xuNiJi_name)
sum_t = sum_t + input_xuNiJi_num
result.append(input_xuNiJi_name+" "+str(input_xuNiJi_num))
result.insert(0,str(sum_t))
result.append("")
result.append(len(zx_wuLiJis))
#print(result)
for i in range(0,len(zx_wuLiJis),1):
zx_wuLiJi = zx_wuLiJis[i]
sss = str(i+1)
temp = {}
for xuNiJi in zx_wuLiJi :
if(temp.has_key(xuNiJi)):
temp[xuNiJi] = temp[xuNiJi] + 1
else:
temp[xuNiJi] = 1
#print(temp)
for name in temp:
sss = sss+" "+name+" "+str(temp[name])
#print(sss)
result.append(sss.strip())
return result
def predict_vm(ecs_lines, input_lines):
# Do your work from here#
result = []
if ecs_lines is None:
print('ecs information is none')
return result
if input_lines is None:
print('input file information is none')
return result
#########训练集的时间跨度#####训练第一天的0点 预测第一天的0点##################
ecs_first_date_zero = ecs_lines[0].split(
"\t")[2].strip().split()[0] + " " + "00:00:00"
ecs_first_date_zero = time.strptime(ecs_first_date_zero,
"%Y-%m-%d %H:%M:%S")
input_first_date_zero = input_lines[-2].strip().split(
)[0] + " " + "00:00:00"
input_first_date_zero = time.strptime(input_first_date_zero,
"%Y-%m-%d %H:%M:%S")
kuadu_first_last_day = (time.mktime(input_first_date_zero) -
time.mktime(ecs_first_date_zero)) / nd
kuadu_first_last_day = int(kuadu_first_last_day)
#print(u"时间跨度为"+str(kuadu_first_last_day))
#########训练集的时间跨度#####训练第一天的0点 预测第一天的0点##################
##########获取训练集中的数据 行数为虚拟机的规格 列数是天数##################
ecs_xunlian = []
for i in range(30):
t = []
for j in range(kuadu_first_last_day):
t.append(0)
ecs_xunlian.append(t)
for ecs_line in ecs_lines:
ecs_line = ecs_line.strip()
ecs_now_name = ecs_line.split("\t")[1]
ecs_now_no = int(ecs_now_name.replace("flavor", ""))
ecs_now_date = ecs_line.split("\t")[2]
ecs_now_date = time.strptime(ecs_now_date, "%Y-%m-%d %H:%M:%S")
#print(ecs_now_name+" "+str(ecs_now_no)+" "+str(ecs_now_date))
ecs_kuadu_first_now_day = (time.mktime(ecs_now_date) -
time.mktime(ecs_first_date_zero)) / nd
ecs_kuadu_first_now_day = int(ecs_kuadu_first_now_day)
ecs_xunlian[ecs_now_no][ecs_kuadu_first_now_day] = ecs_xunlian[
ecs_now_no][ecs_kuadu_first_now_day] + 1
'''
print(u"训练集中的数据")
print(len(ecs_xunlian))
print(len(ecs_xunlian[0]))
temp = pymatrix.matrix(ecs_xunlian)
print(temp)
'''
##########获取训练集中的数据 行数为虚拟机的规格 列数是天数##################
###############去噪的代码################
#获得要预测的规格
input_num = int(input_lines[2].strip())
input_nos = []
for i in range(input_num):
input_line = input_lines[i + 3]
input_no = input_line.strip().split()[0].replace("flavor", "")
input_no = int(input_no)
input_nos.append(input_no)
train_data = fluth_data.quZao2(ecs_xunlian, input_nos)
##############去噪的代码################
###########获得预测跨度####################
#预测的第一天 预测的最后一天
input_first_date = input_lines[-2].strip()
input_first_date = time.strptime(input_first_date, "%Y-%m-%d %H:%M:%S")
input_last_date = input_lines[-1].strip()
input_last_date = time.strptime(input_last_date, "%Y-%m-%d %H:%M:%S")
kuadu_first_last_day = (time.mktime(input_last_date) -
time.mktime(input_first_date)) / nd
kuadu_first_last_day = int(kuadu_first_last_day)
#print(u"时间跨度为："+str(kuadu_first_last_day))
###########获得预测跨度####################
###############获得虚拟机名和预测台数的对应####################
yuce_flvorname_flavornum_s = {}
#print(u"===去噪之后===")
for t in train_data:
name = "flavor" + str(t)
num = sum(train_data[t][:30:1])
num = float(num) / float(30) * float(kuadu_first_last_day)
num = ceil(num)
yuce_flvorname_flavornum_s[name] = int(num)
#print(str(t)+" "+str(train_data[t]))
#print(u"预测值："+str(num))
print("==============")
######################################################
###################获得names cpus mems这三个序列######################
cpus = []
mems = []
names = []
#input文件中需要预测的虚拟机[("flavor1",12,1024),("flavor1",12,1024)]
input_xuNiJis = []
i = 3
while (i < 3 + int(input_lines[2].strip())):
input_now_flavor_name = input_lines[i].strip().split(" ")[0]
input_now_flavor_CPU = int(input_lines[i].strip().split(" ")[1])
input_now_flavor_MEM = int(input_lines[i].strip().split(" ")[2]) / 1024
input_now_flavor = [
input_now_flavor_name, input_now_flavor_CPU, input_now_flavor_MEM
]
input_xuNiJis.append(input_now_flavor)
nums = yuce_flvorname_flavornum_s[input_now_flavor_name]
for j in range(nums):
names.append(input_now_flavor_name)
cpus.append(input_now_flavor_CPU)
mems.append(input_now_flavor_MEM)
i = i + 1
print(names)
print(mems)
print(cpus)
###################获得names cpus mems这三个序列######################
################# 获得物理机的规格###############
input_wuLiJi_cpu = int(input_lines[0].split(" ")[0])
input_wuLiJi_mem = int(input_lines[0].split(" ")[1])
########################获得物理机的规格#########
##################### 优化的维度 装箱 输出结果#####################
input_weidu = input_lines[3 + int(input_lines[2].strip()) + 1].strip()
if (input_weidu == "CPU"):
zx_wuLiJis, _ = memory_alloction.get_memory_allocation(
input_wuLiJi_cpu, input_wuLiJi_mem, cpus, mems, names)
elif (input_weidu == "MEM"):
zx_wuLiJis, _ = memory_alloction.get_memory_allocation(
input_wuLiJi_mem, input_wuLiJi_cpu, mems, cpus, names)
else:
print("出错了，别玩了")
print(zx_wuLiJis)
#开始输出结果
result = []
sum_t = 0
for input_xuNiJi in input_xuNiJis:
input_xuNiJi_name = input_xuNiJi[0]
input_xuNiJi_num = yuce_flvorname_flavornum_s.get(input_xuNiJi_name)
sum_t = sum_t + input_xuNiJi_num
result.append(input_xuNiJi_name + " " + str(input_xuNiJi_num))
result.insert(0, str(sum_t))
result.append("")
result.append(len(zx_wuLiJis))
print(result)
for i in range(0, len(zx_wuLiJis), 1):
zx_wuLiJi = zx_wuLiJis[i]
sss = str(i + 1)
temp = {}
for xuNiJi in zx_wuLiJi:
if (temp.has_key(xuNiJi)):
temp[xuNiJi] = temp[xuNiJi] + 1
else:
temp[xuNiJi] = 1
print(temp)
for name in temp:
sss = sss + " " + name + " " + str(temp[name])
print(sss)
result.append(sss.strip())
return result