def get_clientBitrate():
bSet = [350, 600, 1000, 2000, 3000]
rttDict = util.get_rttDict()
traceDir = "../data/trace/pure/trace1"
avgBList = []
for fileName in os.listdir(traceDir):
ip = fileName[:-4].split("_")[-1]
if ip in rttDict:
print(ip,"\t", rttDict[ip])
else:
print(ip, "not have rtt")
filePath = traceDir + "/" + fileName
lines = open(filePath).readlines()[1:]
totalB = 0
reqCount = 0
for line in lines:
elements = line.split("\t")
bitrate = int(elements[6])/1024/1024
bI = int(elements[4])
totalB += bSet[bI]
reqCount += 1
avgBList.append(totalB*1.0/reqCount)
util.drawCDF(np.array(avgBList), marker=util.markerL[0], pointNum=10, color="#000000")
# plt.title("client average bitrate CDF")
plt.xlabel("bitrate/kbps", fontsize=25)
plt.ylabel("CDF", fontsize=25)
plt.tick_params(labelsize=23)
plt.grid(ls='--')
plt.savefig("./plot/clientBitrate.pdf", bbox_inches = 'tight')
plt.show()
print("total bitrate=",sum(avgBList))
print("miss total bitrate=", sum(avgBList)*0.6)
def draw_lossCDF(modelFileDir):
txtFileDir = modelFileDir + "/test/txt"
lossListNeural = np.loadtxt(txtFileDir + "/neural.txt") / 1024 / 1024
lossListLinearRegression = np.loadtxt(txtFileDir +
"/linearRegresion.txt") / 1024 / 1024
colorL = [
"#98133a", "#ec7c61", "#efa446", "#9c6ce8", "#6ccba9", "#A9CADB",
"#d55e00"
]
markerL = ["s", "x", "o", "^", "|", "D"]
fontSize = 12
util.drawCDF(lossListNeural,
label="neural",
marker=markerL[0],
color=colorL[0])
util.drawCDF(lossListLinearRegression,
label="linear regression",
marker=markerL[1],
color=colorL[1])
plt.legend(loc='best', fontsize=fontSize)
plt.xlabel("loss/Mbps")
plt.ylabel("cdf")
plt.show()
plt.savefig(txtFileDir + "/lossCDF.pdf")
def cdf_segSize():
labels = ["350", "600", "1000", "2000", "3000"]
for bIndex in range(5):
data = np.loadtxt("./file/segSize/segSize"+str(bIndex+1)+".txt")
util.drawCDF(data=data/1024/1024, label=labels[bIndex], color=util.colorL[bIndex], pointNum=50)
plt.xlabel("video chunk size(MB)", fontsize=25)
plt.ylabel("CDF", fontsize=25)
plt.legend(loc='best', fontsize=21)
plt.tick_params(labelsize=23)
plt.xlim(0, 2)
plt.grid(ls='--')
plt.savefig("./plot/segSize.pdf", bbox_inches = 'tight')
plt.show()
def get_clientRTT():
rttDict = util.get_rttDict()
valueL = []
for ip in rttDict:
valueL.append(float(rttDict[ip]))
util.drawCDF(data=np.array(valueL), marker=util.markerL[0], color="#000000")
# plt.title("client rtt CDF")
plt.tick_params(labelsize=23)
plt.xlabel("rtt/ms", fontsize=25)
plt.ylabel("CDF", fontsize=25)
plt.xticks([0, 100, 200, 300, 400])
plt.grid(ls='--')
plt.savefig("./plot/clientRTT.pdf", bbox_inches = 'tight')
plt.show()
print("average rtt=", sum(valueL)/len(valueL))
def cdf_bandwidth():
# matplotlib.use('agg')
dir = "../data/bandwidth/train/"
bwTypes = ["FCC", "HSDPA", "mine"]
# fig = plt.figure(figsize=(12,5))
for bwType in bwTypes:
bwList = []
path = dir + bwType
if bwType.find('mine') != -1:
print()
ipList = os.listdir(path)
for ip in ipList:
path_ = path + "/" + ip
for fileName in os.listdir(path_):
data = np.loadtxt(path_ + "/" + fileName)[:, 1]
dataL = data.flatten().tolist()
for d in range(len(dataL)):
if dataL[d] > 11*1024*1024:
dataL[d] = 11*1024*1024
bwList = bwList + dataL
else:
for fileName in os.listdir(path):
data = np.loadtxt(path + "/" + fileName)[:, 1]
dataL = data.flatten().tolist()
for d in range(len(dataL)):
if dataL[d] > 11 * 1024 * 1024:
dataL[d] = 11 * 1024 * 1024
bwList = bwList + dataL
bwIndex = bwTypes.index(bwType)
util.drawCDF(data=np.array(bwList)/1024/1024,
pointNum=10,
label=bwType, color=util.colorL[bwIndex], marker=util.markerL[bwIndex])
# plt.title("defferent type bandwidth compare")
plt.tick_params(labelsize=23)
plt.xlabel("bandwidth(Mbps)", fontsize=25)
plt.ylabel("CDF", fontsize=25)
plt.grid(ls='--')
plt.legend(loc='best', fontsize=23)
plt.xlim(0, 10)
plt.savefig("./plot/bandwidth.pdf", bbox_inches = 'tight')
plt.show()
def cdf_hitMissThroughput():
data = np.loadtxt("../data/throughputRelation/data/2/train/sample.csv", skiprows=1)
# size hThroughput mThroughput hTime mTime rtt maxMT reqCount totalMT avgMT
data_hThroughput = data[:, 1].flatten()
data_mThroughput = data[:, 2].flatten()
print(np.average(data_hThroughput))
print(np.average(data_mThroughput))
# fig = plt.figure(figsize=(4, 3))
util.drawCDF(data=data_hThroughput/1024/1024, label="hit throughput", marker=util.markerL[0], color=util.colorL[0])
util.drawCDF(data=data_mThroughput/1024/1024, label="miss throughput", marker=util.markerL[1], color=util.colorL[1])
plt.legend(loc='best', fontsize=20)
plt.tick_params(labelsize=23)
plt.xlabel("Throughput(Mbps)", fontsize=25)
plt.ylabel("CDF", fontsize=25)
dt = util.get_date(timeFlag=False)
plt.grid(ls='--')
plt.savefig("./plot/cdf_hitMissThroughput_"+dt+".pdf", bbox_inches = 'tight')
plt.show()
def cdf_policy(dir):
table = PrettyTable(["bwType", "policy", "avg QoE", "avg reward", "avg rebuffer", "hit ratio", "byte hit ratio", "avg bitrate variation", "avg bitrate"])
bwTypes = ["FCC", "HSDPA", "mine"]
for bwType in bwTypes:
qoeL = []
bitrateL = []
rebL = [[]]
bVarL = [[]]
hitRL = []
polDir = os.listdir(dir + bwType)
polCount = len(polDir)
for i in range(polCount):
qoeL.append([])
bitrateL.append([0] * 5)
rebL.append([])
bVarL.append([])
hitRL.append(0)
for polI in range(len(polDir)):
pol = polDir[polI]
hitCount = 0
hitByte = 0
segCount = 0
total_rew = 0
total_qoe = 0.
total_reb = 0.0
total_osc = 0.0
total_b = 0.0
for traceFName in os.listdir(dir + bwType + "/" + pol):
file = open(dir + bwType + "/" + pol + "/" + traceFName)
lines = file.readlines()[1:]
segCount += len(lines)
last_br = 0
for line in lines:
# No cSize 2Hit buffer bI aBI lastBI 7bitrate throughput hThroughput mThroughput downloadT
# 12rebufferT qoe reward time busy
elements = line.split("\t")
# bitrate index ---------------------------
bI = int(elements[5])
bitrateL[polI][bI] += 1
# bitrate variation -----------------------
bitrate = int(elements[7]) * 1.0 / 1024 / 1024 # Mbps
total_b += bitrate
total_osc += abs(last_br - bitrate)
bVarL[polI].append(abs(last_br - bitrate))
last_br = bitrate
# hit -------------------------------------
hit = int(elements[2])
if hit == 1:
hitCount += 1
hitByte += bitrate
# rebufferT -------------------------------
reb = float(elements[-5])
total_reb += reb
if reb > 20000:
print(traceFName, line)
# if reb > 5:
# reb = 5
rebL[polI].append(reb)
# qoe -------------------------------------
qoe = float(elements[-4])
# if qoe < -5:
# qoe = -5
total_qoe += qoe
qoeL[polI].append(qoe)
# reward -----------------------------------
reward = float(elements[-3])
total_rew += reward
hitRL[polI] = 1.0 * hitByte / total_b
# print(bwType, pol, "avg qoe=", total_rew / segCount, ",avg rebuf=", total_reb / segCount, ",hit ratio=",
# 1.0 * hitCount / segCount, ",byte hit ratio=", 1.0 * hitByte / total_b, ",avg bitrate variation=",
# total_osc / segCount, ",avg bitrate=", total_b / segCount)
table.add_row([bwType, pol, total_qoe / segCount, total_rew / segCount, total_reb / segCount,
1.0 * hitCount / segCount, 1.0 * hitByte / total_b,
total_osc / segCount, total_b / segCount])
fig = plt.figure(figsize=(20, 4))
fontSize = 10
# qoe-----------------------
ax1 = fig.add_subplot(1, 5, 1)
for polI in range(len(polDir)):
pol = polDir[polI]
util.drawCDF(np.array(qoeL[polI]), pol, color=util.colorL[polI])
plt.xlabel("qoe", fontsize=fontSize)
plt.ylabel("cdf", fontsize=fontSize)
plt.legend(loc='best', fontsize=fontSize)
plt.xticks(fontsize=fontSize)
plt.yticks(fontsize=fontSize)
# plt.xlim(0.8, 2.1)
# plt.ylim(0.5, 1.01)
# bitrate-----------------------
bitrateL = np.array(bitrateL)
ax2 = fig.add_subplot(1, 5, 2)
n_groups = 5
opacity = 0.8
bar_width = 0.15
colors = ["#98133a", "#ec7c61", "#efa446", "#9c6ce8", "#6ccba9", "#A9CADB", "#d55e00"]
index = np.arange(n_groups)
for polI in range(len(polDir)):
pol = polDir[polI]
rects = plt.bar(index + bar_width * (polI - 2.5), 1.0 * bitrateL[polI, :] / np.sum(bitrateL[polI, :]) * 100,
bar_width,
alpha=opacity, color=colors[polI],
label=pol)
plt.xlabel("bitrate(kbps)", fontsize=fontSize)
plt.ylabel("request count(%)", fontsize=fontSize)
# plt.ylim(0, 55)
plt.legend(loc='best', fontsize=fontSize)
plt.xticks(index, ('350', '600', '1000', '2000', '3000'), fontsize=fontSize)
plt.yticks(fontsize=fontSize)
# rebuffer-----------------------
ax3 = fig.add_subplot(1, 5, 3)
for polI in range(len(polDir)):
pol = polDir[polI]
util.drawCDF(np.array(rebL[polI]), pol, color=util.colorL[polI])
plt.legend(loc='best', fontsize=fontSize)
plt.xticks(fontsize=fontSize)
plt.yticks(fontsize=fontSize)
plt.xlabel("rebuffer time", fontsize=fontSize)
plt.ylabel("cdf", fontsize=fontSize)
# bitrate variation-----------------
ax3 = fig.add_subplot(1, 5, 4)
for polI in range(len(polDir)):
pol = polDir[polI]
util.drawCDF(np.array(bVarL[polI]), pol, color=util.colorL[polI])
plt.legend(loc='best', fontsize=fontSize)
plt.xticks(fontsize=fontSize)
plt.yticks(fontsize=fontSize)
plt.xlabel("bitrate variation", fontsize=fontSize)
plt.ylabel("cdf", fontsize=fontSize)
# hit ratio----------------
ax3 = fig.add_subplot(1, 5, 5)
n_groups = polCount
opacity = 0.8
bar_width = 0.35
index = np.arange(polCount)
plt.bar(index, np.array(hitRL), bar_width)
plt.ylabel('hit ratio(%)')
ticksList = []
for i in range(polCount):
ticksList.append(polDir[i])
# plt.xticks(index, (polDir[0], polDir[1], polDir[2], polDir[3], polDir[4]))
plt.xticks(index, ticksList)
plt.title(bwType)
plt.savefig("./plot/cdf_policy_hitratio.pdf")
plt.show()
print(table.get_string())