def preprocessing(lc_data, windowSize=50):
lc_nor = TimeSeriesScalerMeanVariance(mu=0., std=1.).fit_transform(
[lc_data['instances']])
lc_data['lc_nor'] = lc_nor
paa = ut_gen.genListPAA(instances_nor=lc_nor,
windowSize=windowSize,
timestamp=lc_data['timestamp'])
lc_data['paa'] = paa
sax = ut_gen.genListSAX(instances_nor=lc_nor,
windowSize=windowSize,
timestamp=lc_data['timestamp'],
n_sax_symbols=n_sax_symbols)
lc_data['sax'] = sax
one_sax = ut_gen.genList1D_SAX(instances_nor=lc_nor,
windowSize=windowSize,
timestamp=lc_data['timestamp'],
n_sax_symbols_slope=n_sax_symbols_slope,
n_sax_symbols_avg=n_sax_symbols_avg)
lc_data['one_sax'] = one_sax
corePlot = sketchDyBinService(windowSize=windowSize,
initialBin=5,
isOnline=False)
sketchInstances = corePlot.sketchMode(instances=list(lc_nor[0].ravel()))
lc_data['dy_bin'] = {
'sketchInstances': sketchInstances,
'timestamp': lc_data['timestamp']
}
print("a")
def dy_tran():
if request.method == 'POST':
listKeys = [
'inputWindowSize', 'inputInitialBin', 'isOnline', 'fileName'
]
inputKeys = request.form.keys()
if ut_service.isCompleteInputKey(listKeys=listKeys,
inputKeys=inputKeys):
FdataMDF, FtimestampMDF = ut_service.getMDFData(
request.form.get('fileName'))
windowSize = int(request.form.get('inputWindowSize'))
initialBin = int(request.form.get('inputInitialBin'))
inputOnline = bool(request.form.get('isOnline'))
corePlot = sketchDyBinService(windowSize=windowSize,
initialBin=initialBin,
isOnline=inputOnline)
sketchInstances = corePlot.sketchMode(instances=FdataMDF)
indexBinList = corePlot.getBinNameInstances()
window = corePlot.getWindow()
else:
return jsonify(
status="404",
message="Keys are incorrect",
)
return render_template("html/mdf/mdf_main.html", listFiles=[])
def ratioPlot():
listFiles = ut_mdf.getListMDF()
if request.method == 'POST':
fileName = str(request.form.get('selectFile'))
FdataMDF, FtimestampMDF = ut_service.getMDFData(fileName)
# sketch
windowSize = int(request.form.get('inputWindowSize'))
initialBin = int(request.form.get('inputInitialBin'))
x_axis = FtimestampMDF
# corePlot = sketchService(windowSize=windowSize, initialBin=3)
# sketch3Instances = corePlot.sketchMode(instances=FdataMDF)
corePlot = sketchDyBinService(windowSize=windowSize, initialBin=3)
sketchInstances = corePlot.sketchMode(instances=FdataMDF)
print("sketch {}".format(initialBin))
bin3Instnace = ut_gen.genFixBin(binSize=200, instances=FdataMDF)
print("fix 3")
fixBinInstnace = ut_gen.genFixBin(binSize=initialBin,
instances=FdataMDF)
print("fix {}".format(initialBin))
# jsMDF, divMDF = ut_bokeh.JSandDivMutliplePlot(x_axis=x_axis,
# y_axisList = [FdataMDF,sketch3Instances,sketchInstances,bin3Instnace,fixBinInstnace],
# circleList = [True,False,False,False,False],
# legend_labelList = ['Raw','DyBin3','DyBin{}'.format(initialBin),'Bin size = 3','Bin size = {}'.format(initialBin)],
# line_alphaList = [0.4,1,1,1,1],
# title=fileName)
jsMDF, divMDF = ut_bokeh.JSandDivMutliplePlot(
x_axis=x_axis,
y_axisList=[FdataMDF, sketchInstances, bin3Instnace],
circleList=[True, False, False],
legend_labelList=['Raw', 'DyBin', 'Bin size = 200'],
line_alphaList=[0.4, 1, 1],
title=fileName)
core = com_service(inputList=FdataMDF)
# dictResult = core.TWINcurveBinSize(maxBinSize=len(x_axis))
# jsCom, divCom = ut_bokeh.JSandDivComPlot(binSizeList=dictResult["binSizeList"], comList=dictResult["comList"],
# varList=dictResult["varList"])
# return render_template("html/ratio/ratio_plot.html", jsMDF=jsMDF, divMDF=divMDF
# , jsCom=jsCom, divCom=divCom, listFiles=listFiles)
dictResult = core.TWINcurveWindowSize()
# dictResult = core.TWINcurveWindowSizeFixBin(timestamps=FtimestampMDF)
jsCom, divCom = ut_bokeh.JSandDivComPlotTemp(
binSizeList=dictResult["binSizeList"],
comList=dictResult["comList"],
varList=dictResult["varList"])
return render_template("html/ratio/ratio_plot.html",
jsMDF=jsMDF,
divMDF=divMDF,
jsCom=jsCom,
divCom=divCom,
listFiles=listFiles)
def TWINcomputeCompression(self, windowSize):
corePlot = sketchDyBinService(windowSize=windowSize,
initialBin=3,
isOnline=False)
sketchInstances = corePlot.sketchMode(instances=self.inputList)
varCur = variance(sketchInstances)
varMax = variance(self.inputList)
comCur = self.compressionRatioWindowSize(windowSize=windowSize)
# comMax = len(self.inputList)
return {"varaince_ratio": varCur / varMax, "compression_ratio": comCur}
def offline_dysketch():
if request.method == 'POST':
windowSize = int(request.form.get('inputWindowSize'))
initialBin = int(request.form.get('inputInitialBin'))
fileInput = request.files['file']
fileName = secure_filename(fileInput.filename)
instances = [float(line.strip().decode("utf-8")) for line in fileInput]
timeFileInput = request.files['TimestampFileInput']
timeFileName = secure_filename(timeFileInput.filename)
timeFileInput = request.files['TimestampFileInput']
timeFileName = secure_filename(timeFileInput.filename)
if timeFileName == '':
x_axis = list(range(len(instances)))
else:
tempX_axis = [
float(line.strip().decode("utf-8")) for line in timeFileInput
]
if len(tempX_axis) == len(instances):
x_axis = tempX_axis
else:
return render_template(
'inputplot.html',
error="instances of two inputs are not equal")
corePlotOffline = sketchDyBinService(windowSize=windowSize,
initialBin=initialBin,
isOnline=False)
offlineSketchInstances = corePlotOffline.sketchMode(
instances=instances)
jsRaw, divRaw = ut_bokeh.JSandDivLinePlot(x_axis=x_axis,
y_axis=instances,
title="Raw data")
jsOff, divOff = ut_bokeh.JSandDivLinePlot(
x_axis=x_axis,
y_axis=offlineSketchInstances,
# change_points=change_points,
title="Sketching from Offile Dynamic Binning",
isCanExport=True)
rows = corePlotOffline.getDataTableMeanVarianceBin()
return render_template("result_offline.html",
windowSize=windowSize,
initialBin=initialBin,
fileName=fileName,
jsRaw=jsRaw,
divRaw=divRaw,
jsOff=jsOff,
divOff=divOff,
rows=rows)
def export_JsDiv_rawdy(data):
list_ini_bin = [3, 5, 7, 10]
TOOLTIPS = [("index", "$index"), ("(x,y)", "@x{0,0.000000}, $y"),
("UTC", "@UTC")]
instances = [float(i) for i in data["instances"]]
timestamp = [float(i) for i in data["timestamps"]]
UTC = ut_astro.convertList_MJDtoUTC(timestamp)
fileName = data["fileName"]
plot = figure(tooltips=TOOLTIPS,
title="Result : {}".format(fileName),
x_axis_label='time',
y_axis_label='Flux',
sizing_mode="stretch_both")
source = ColumnDataSource(data=dict(x=timestamp, y=instances, UTC=UTC))
plot.line('x',
'y',
source=source,
line_alpha=1,
color="black",
line_width=2,
legend_label="Raw data")
plot.circle('x',
'y',
source=source,
color="black",
legend_label="Raw data")
windowSize = int(data["windowSize"])
corePlot = sketchDyBinService(windowSize=windowSize,
initialBin=5,
isOnline=False)
sketchInstances = corePlot.sketchMode(instances=instances)
source = ColumnDataSource(data=dict(x=timestamp, y=sketchInstances))
plot.line('x',
'y',
source=source,
line_alpha=1,
color="red",
line_width=2,
legend_label="DyBin")
plot.legend.border_line_width = 3
plot.legend.click_policy = "hide"
plot.legend.border_line_color = "navy"
plot.legend.border_line_alpha = 0.
plot.xaxis.axis_label_text_font_size = "16pt"
plot.xaxis.major_label_text_font_size = "13pt"
plot.yaxis.axis_label_text_font_size = "16pt"
plot.yaxis.major_label_text_font_size = "13pt"
js, div = components(plot)
return js, div
def getSublenght(period,mdfData):
corePlot = sketchDyBinService(windowSize=window_size, initialBin=ini_bin, isOnline=False)
corePlot.sketchMode(instances=mdfData['instances'])
window = corePlot.getWindow()
prior_index = period
cur_index = period+1
start_point = 0
for i in range(0,prior_index):
start_point = start_point + window[i].get_number_instance()
print(start_point)
end_point = start_point + window[prior_index].get_number_instance() + window[cur_index].get_number_instance()
print(end_point)
return start_point,end_point
def sketchDynamicBinning():
if request.method == 'POST':
inputKeys = ['inputWindowSize', 'inputInitialBin', 'isOnline']
fileKeys = ['datastreamInputFile']
intersection_inputKeys = set.intersection(set(inputKeys),
set(request.form.keys()))
intersection_fileKeys = set.intersection(set(fileKeys),
set(request.files.keys()))
if (len(intersection_inputKeys) == len(inputKeys)) & (
len(fileKeys) == len(intersection_fileKeys)):
try:
windowSize = int(request.form.get('inputWindowSize'))
initialBin = int(request.form.get('inputInitialBin'))
isOnline = bool(request.form.get('isOnline'))
fileInput = request.files['datastreamInputFile']
fileName = secure_filename(fileInput.filename)
instances = [
float(line.strip().decode("utf-8")) for line in fileInput
]
corePlot = sketchDyBinService(windowSize=windowSize,
initialBin=initialBin,
isOnline=isOnline)
sketchInstances = corePlot.sketchMode(instances=instances)
segmentInstances = corePlot.getListMeanBin()
transList = []
######### gen Tran and T-test ###########
# threshold_tTest = float(request.form.get('T_test'))
# dictResult = corePlot.getListResultTest()
# transList = ut_service.genTranFromTtest(dictResult=dictResult,
# threshold_tTest=threshold_tTest)
# ut_service.exportCSVTtest(dictResult=dictResult,fileName=fileName)
######### gen Tran and T-test ###########
return jsonify(data_normalization=sketchInstances,
data_segment=segmentInstances,
segment_size=windowSize,
status="normal",
transList=transList)
except Exception as e:
return jsonify(
status="404",
message='inputs are incorrect',
)
else:
return jsonify(
status="404",
message="Keys are incorrect",
)
def sketchBinInWindow(instances,
windowSize,
isFixBin=True,
initialBin=3,
isOnline=True):
if isFixBin:
print("a")
else:
corePlot = sketchDyBinService(windowSize=windowSize,
initialBin=initialBin,
isOnline=isOnline)
corePlot.sketchMode(instances=instances)
window = corePlot.getWindow()
return window
def TWINcurveWindowSize(self, minWindowSize=20, isRatio=True):
dictResult = {}
varList = []
comList = []
maxWindowSize = ceil(len(self.inputList) / float(3))
windowSizeList = [2, 3, 5, 7, 12, 18
] + [*range(minWindowSize, 300, 15)]
varMax = variance(self.inputList)
winSize = []
for windowSize in windowSizeList:
print(windowSize)
winSize.append(windowSize)
corePlot = sketchDyBinService(windowSize=windowSize,
initialBin=3,
isOnline=False)
sketchInstances = corePlot.sketchMode(instances=self.inputList)
var = variance(sketchInstances)
# var = corePlot.getVarianceWindow(isNormalization=False)
varList.append(var)
comList.append(
self.compressionRatioWindowSize(windowSize=windowSize))
# add max
comList.append(len(self.inputList))
varList.append(varMax)
windowSizeList.append(len(self.inputList))
if isRatio:
dictResult["varList"] = ut.calToPercent(max=varMax,
listInput=varList)
else:
dictResult["varList"] = varList
dictResult["comList"] = ut.calToPercent(max=len(self.inputList),
listInput=comList)
dictResult["binSizeList"] = winSize
x0 = windowSizeList[ceil(len(windowSizeList) / 2)]
x1 = windowSizeList[-1]
y0 = dictResult["varList"][ceil(len(windowSizeList) / 2)]
y1 = dictResult["varList"][-1]
dictResult["interpolationList"] = self.linearInterpolation(
y1=y1, y0=y0, x1=x1, x0=x0, xAxisList=windowSizeList)
return dictResult
def export_SimultaneousDybin(listData, initialBin=3, isJSDIV=True):
TOOLTIPS = [("index", "$index"), ("(x,y)", "(@x{0,0}, @y{0,0.000}"),
("Index Bin", "@names")]
plot = figure(tooltips=TOOLTIPS,
title="Result Dynamic binning",
x_axis_label='time',
y_axis_label='Flux',
sizing_mode="stretch_both")
for data, color in zip(listData, Spectral10):
instances = [float(i) for i in data["instances"]]
timestamp = [float(i) for i in data["timestamp"]]
fileName = data["fileName"]
windowSize = int(data["windowSize"])
corePlot = sketchDyBinService(windowSize=windowSize,
initialBin=initialBin,
isOnline=False)
sketchInstances = corePlot.sketchMode(instances=instances)
source = ColumnDataSource(data=dict(x=timestamp, y=sketchInstances))
plot.line('x',
'y',
source=source,
line_alpha=1,
color=color,
line_width=2,
legend_label=fileName)
plot.circle('x',
'y',
source=source,
color=color,
legend_label=fileName)
plot.legend.border_line_width = 3
plot.legend.click_policy = "hide"
plot.legend.border_line_color = "navy"
plot.legend.border_line_alpha = 0.
plot.xaxis.axis_label_text_font_size = "16pt"
plot.xaxis.major_label_text_font_size = "13pt"
plot.yaxis.axis_label_text_font_size = "16pt"
plot.yaxis.major_label_text_font_size = "13pt"
if isJSDIV:
js, div = components(plot)
return js, div
else:
return plot
def computeResultWinSize(self, windowSize, isRatio=False):
corePlot = sketchDyBinService(windowSize=windowSize,
initialBin=3,
isOnline=False)
sketchInstances = corePlot.sketchMode(instances=self.inputList)
var = variance(sketchInstances)
compress = self.compressionRatioWindowSize(windowSize=windowSize)
if isRatio:
varMax = variance(self.inputList)
var = float(var) / float(varMax)
compress = compress / float(len(self.inputList))
dictResult = {
"variance": var,
"compress": compress,
"windowSize": windowSize
}
return dictResult
def topDetail(fileInput):
data = ut_mdf.getMDFdata(fileName=fileInput)
corePlot = sketchDyBinService(windowSize=5, initialBin=3, isOnline=False)
sketchInstances = corePlot.sketchMode(instances=data["data"])
TOOLTIPS = [
("index", "$index"),
("(x,y)", "@x{0,0.000000}, $y"),
]
js, div = ut_bokeh.JSandDivDoublePlotStandard(x_axis=data["timestamp"],
y_axisRaw=data["data"],
y_axisBin=sketchInstances,
title=data["fileName"],
TOOLTIPS=TOOLTIPS)
rows = db.getDTW(data["fileName"])
return render_template("html/topList/topList_detail.html",
jsMDF=js,
divMDF=div,
fileName=data["fileName"],
rows=rows)
def MDFPlot():
listFiles = ut_mdf.getListMDF()
if request.method == 'POST':
fileName = str(request.form.get('selectFile'))
FdataMDF, FtimestampMDF = ut_service.getMDFData(fileName)
# sketch
windowSize = int(request.form.get('inputWindowSize'))
initialBin = int(request.form.get('inputInitialBin'))
inputOnline = request.form.get('inputOnline')
# if inputOnline == "True":
# isOnline = True
# else:
# isOnline = False
isOnline = False
# print("**************{}***********".format(isOnline))
corePlot = sketchDyBinService(windowSize=windowSize,
initialBin=initialBin,
isOnline=isOnline)
threshold_tTest = float(request.form.get('threshold_tTest'))
threshold_fTest = float(request.form.get('threshold_fTest'))
sketchInstances = corePlot.sketchMode(instances=FdataMDF)
indexBinList = corePlot.getBinNameInstances()
getListMeanBin = corePlot.getListMeanBin()
print(getListMeanBin)
dictResult = corePlot.getListResultTest()
js, div = ut_bokeh.JSandDivRawAndBin(x_axis=FtimestampMDF,
y_raw=FdataMDF,
y_axisList=[sketchInstances],
legend_labelList=["dyBin"],
namesList=[indexBinList],
title="{} window size :{}".format(
fileName, windowSize))
return render_template("html/mdf/mdf_plot.html",
jsMDF=js,
divMDF=div,
listFiles=listFiles)
def lcPlot():
listFiles = ut_service.getListLC_test()
if request.method == 'POST':
fileName = str(request.form.get('selectFile'))
inputDuration = int(request.form.get('inputDuration'))
inputHeight = int(request.form.get('inputHeight'))
windowSize = int(request.form.get('inputWindowSize'))
initialBin = int(request.form.get('inputInitialBin'))
rawInstances, transList = ut_service.getDataLC_test(
fileName, L=int(inputHeight), I=int(inputDuration))
x_axis = list(range(len(rawInstances)))
corePlot = sketchDyBinService(windowSize=windowSize,
initialBin=initialBin,
isOnline=False)
sketchInstances = corePlot.sketchMode(instances=rawInstances)
dictResult = corePlot.getListResultTest()
threshold_tTest = float(request.form.get('threshold_tTest'))
if threshold_tTest == 0:
alarmList = []
else:
alarmList = ut_service.genTranFromTtest(
dictResult=dictResult, threshold_tTest=threshold_tTest)
js, div = ut_bokeh.JSandDivDoublePlotWithToggle(
x_axis=x_axis,
y_axisRaw=rawInstances,
y_axisBin=sketchInstances,
title=fileName,
transList=transList,
alarmList=alarmList)
rows = corePlot.getDataTableMeanVarianceBin()
return render_template("html/LC_test/lc_test_plot.html",
jsResult=js,
divResult=div,
listFiles=listFiles,
rows=rows)
def genListDyBin(instances,
windowSize,
timestamp,
initialBin=5,
isOnline=False):
corePlot = sketchDyBinService(windowSize=windowSize,
initialBin=initialBin,
isOnline=isOnline)
sketchInstances = corePlot.sketchMode(instances=instances)
indexBinList = corePlot.getBinNameInstances()
window = corePlot.getWindow()
meanList = []
for bin in window:
meanList.append(bin.get_representation())
return {
"sketchInstances": sketchInstances,
"timestamp": timestamp,
"indexBinList": indexBinList,
"window": window,
"variance": variance(meanList),
"mean": mean(meanList)
}
ut_light.getFullPath(height=height, duration=duration))
outputdyFile = "{}dy_html\\".format(
ut_light.getFullPath(height=height, duration=duration))
for mainFile, ansFile in zip(listFile, listAns):
file_name = os.path.basename(mainFile)
mainRaw = [float(item) for item in ut.txt_to_list(mainFile)]
ansRaw = [float(item) for item in ut.txt_to_list(ansFile)]
ansList = []
tranList = []
for ans in ansRaw:
ansList = ansList + ut_light.genListAns(start=ans,
duration=duration)
tranList = {"startTran": ans, "endTran": ans + duration}
corePlot = sketchDyBinService(windowSize=windowSize,
initialBin=initialBin,
isOnline=False)
sketchInstances = corePlot.sketchMode(instances=mainRaw)
window = corePlot.getWindow()
cluster = ut_cluster.cluster_xMean_Dy(binsList=window,
kmax=windowSize,
hist_bin=20)
resultDistance = ut_cluster.clusterMaxDistance(
centers=cluster["centers"])
tranBins = ut_cluster.transientClusterMethod(
maxDistance=resultDistance, clusters=cluster["clusters"])
a = corePlot.getStartEndIndex(indexBinLists=tranBins)
x_axis = list(range(len(mainRaw)))
indexBinList = corePlot.getBinNameInstances()
# export HTML
fig = ut_plotly.export3DClusterDYTemp(
"date20191203", "date20191204", "date20191205", "date20191224",
"date20200130", "date20200201"
]
fields = []
rows = []
if __name__ == '__main__':
for pattern in patterns:
try:
with open("{}_tran.csv".format(pattern), 'r') as csvfile:
# creating a csv reader object
csv_reader = reader(csvfile)
for row in csv_reader:
file_name = row[0]
FdataMDF, FtimestampMDF = ut_service.getMDFData(file_name)
corePlot = sketchDyBinService(windowSize=windowSize,
initialBin=3)
sketchInstances = corePlot.sketchMode(instances=FdataMDF)
indexBinList = corePlot.getBinNameInstances()
plot = ut_bokeh.exportPlotRawAndBin(
x_axis=FtimestampMDF,
y_raw=FdataMDF,
y_axisList=[sketchInstances],
legend_labelList=["dyBin"],
namesList=[indexBinList],
title="{} window size :{}".format(
file_name, windowSize))
plots = [plot]
outputFile = "{}".format(file_name)
# ut_bokeh.exportPlotWeb(path=pathHtmlOutput, fileName=fileName, plot=plot)
ut_bokeh.exportPlotPng(path="tran",
alphabet_size_avg=n_sax_symbols)
sax_dataset_inv = sax.inverse_transform(sax.fit_transform(lc_nor))
# 1d-SAX transform
n_sax_symbols_avg = 5
n_sax_symbols_slope = 5
one_d_sax = OneD_SymbolicAggregateApproximation(
n_segments=n_paa_segments,
alphabet_size_avg=n_sax_symbols_avg,
alphabet_size_slope=n_sax_symbols_slope)
transformed_data = one_d_sax.fit_transform(lc_nor)
one_d_sax_dataset_inv = one_d_sax.inverse_transform(transformed_data)
#dynamic binning
lc_nor_list = list(lc_nor[0].ravel())
corePlot = sketchDyBinService(windowSize=n_paa_segments,
initialBin=3, isOnline=False)
sketchInstances = corePlot.sketchMode(instances=lc_nor_list)
print("a")
plt.figure()
plt.subplot(2, 2, 1) # First, raw time series
plt.plot(timestamps,lc_nor[0].ravel(), "b-")
plt.title("Raw time series")
# plt.subplot(2, 3, 2) # Second, PAA
# plt.plot(timestamps,lc_nor[0].ravel(), "b-", alpha=0.4)
# plt.plot(timestamps,paa_dataset_inv[0].ravel(), "b-")
# plt.title("PAA")
def upload_file():
if request.method == 'POST':
windowSize = int(request.form.get('inputWindowSize'))
initialBin = int(request.form.get('inputInitialBin'))
threshold_tTest = float(request.form.get('threshold_tTest'))
fileInput = request.files['file']
fileName = secure_filename(fileInput.filename)
instances = [float(line.strip().decode("utf-8")) for line in fileInput]
corePlotOnline = sketchDyBinService(windowSize=windowSize,
initialBin=initialBin,
isOnline=True)
onlineSketchInstances = corePlotOnline.sketchMode(instances=instances)
timeFileInput = request.files['TimestampFileInput']
timeFileName = secure_filename(timeFileInput.filename)
if timeFileName == '':
x_axis = list(range(len(onlineSketchInstances)))
else:
tempX_axis = [
float(line.strip().decode("utf-8")) for line in timeFileInput
]
if len(tempX_axis) == len(onlineSketchInstances):
x_axis = tempX_axis
else:
return render_template(
'inputplot.html',
error="instances of two inputs are not equal")
# dictResult = corePlotOnline.getListResultTest()
# transList = ut_service.genTranFromTtest(dictResult=dictResult,
# threshold_tTest=threshold_tTest)
jsRaw, divRaw = ut_bokeh.JSandDivLinePlot(x_axis=x_axis,
y_axis=instances,
title="Raw data")
# jsSK, divSK = ut_bokeh.JSandDivLinePlot(x_axis=x_axis, y_axis=onlineSketchInstances,
# title="Sketching from Dynamic Binning", isCanExport=True)
# rows = corePlotOnline.getDataTableMeanVarianceBin()
corePlotOffline = sketchDyBinService(windowSize=windowSize,
initialBin=initialBin,
isOnline=False)
offlineSketchInstances = corePlotOffline.sketchMode(
instances=instances)
jsCh, divCh = ut_bokeh.JSandDivLinePlot(
x_axis=x_axis,
y_axis=offlineSketchInstances,
# change_points=change_points,
title="Sketching from Offile Dynamic Binning",
isCanExport=True)
rows = corePlotOffline.getDataTableMeanVarianceBin()
return render_template(
"html/dynamicbin/resultplot.html",
windowSize=windowSize,
initialBin=initialBin,
fileName=fileName,
jsRaw=jsRaw,
divRaw=divRaw,
# jsSK=jsSK,
# divSK=divSK,
jsCh=jsCh,
divCh=divCh,
rows=rows)
def clusterPlot():
listFiles = ut_mdf.getListMDF()
if request.method == 'POST':
windowSize = int(request.form.get('inputWindowSize'))
fileName = str(request.form.get('selectFile'))
isDybin = request.form.get('inputDybin')
initialBin = int(request.form.get('inputInitialBin'))
FdataMDF, FtimestampMDF = ut_service.getMDFData(fileName)
corePlot = sketchDyBinService(windowSize=windowSize,
initialBin=5,
isOnline=False)
sketchInstances = corePlot.sketchMode(instances=FdataMDF)
indexBinList = corePlot.getBinNameInstances()
window = corePlot.getWindow()
indexTimestamp = 0
segment3D = []
for index, bin in enumerate(window):
raw = bin.get_raw()
start = copy.copy(indexTimestamp)
indexTimestamp = indexTimestamp + len(raw)
tempTimestamp = FtimestampMDF[start:indexTimestamp]
slope = ut_cal.calSlope(timestamps=tempTimestamp, instances=raw)
result = {
"raw": raw,
"index": index,
"variance": bin.get_variance(),
"mean": bin.get_representation(),
"slope": slope
}
segment3D.append(result)
cluster = ut_cluster.cluster_xMean_Dy(binsList=window,
kmax=windowSize,
hist_bin=20)
ut_plotly.plot3DClusterDYTemp(samples=cluster["samples"],
clusters=cluster["clusters"],
centers=cluster["centers"])
resultCluster = ut_gen.genHistrogram_Dict(binsList=segment3D,
hist_bin=20)
jsMDF, divMDF = ut_bokeh.JSandDivRawAndBin(
x_axis=FtimestampMDF,
y_raw=FdataMDF,
y_axisList=[sketchInstances],
legend_labelList=["dyBin"],
namesList=[indexBinList],
title="{} window size :{}".format(fileName, windowSize))
jsCl, divCl = ut_bokeh.JSandDivHistrogramCluster(
meansClass=resultCluster['meansClass'],
varsClass=resultCluster['varsClass'],
slopesClass=resultCluster['slopesClass'])
return render_template("html/cluster/cluster_plot.html",
listFiles=listFiles,
jsMDF=jsMDF,
divMDF=divMDF,
jsCl=jsCl,
divCl=divCl)
def export_JsDiv_saxcompare(data, add_on=[]):
TOOLTIPS = [("index", "$index"), ("(x,y)", "@x{0,0.000000}, $y"),
("UTC", "@UTC")]
instances = [float(i) for i in data["instances"]]
timestamp = [float(i) for i in data["timestamp"]]
instances_nor = TimeSeriesScalerMeanVariance(mu=0., std=1.).fit_transform(
[instances])
UTC = ut_astro.convertList_MJDtoUTC(timestamp)
fileName = data["fileName"]
windowSize = int(data["windowSize"])
plot = figure(tooltips=TOOLTIPS,
title="Result : {}".format(fileName),
x_axis_label='time',
y_axis_label='Flux',
sizing_mode="stretch_both")
source = ColumnDataSource(
data=dict(x=timestamp, y=list(instances_nor[0].ravel()), UTC=UTC))
plot.line('x',
'y',
source=source,
line_alpha=0.5,
color="black",
line_width=2,
legend_label="Raw data")
plot.circle('x',
'y',
source=source,
alpha=0.7,
color="black",
legend_label="Raw data")
# Dybin
corePlot = sketchDyBinService(windowSize=windowSize,
initialBin=5,
isOnline=False)
sketchInstances = corePlot.sketchMode(
instances=list(instances_nor[0].ravel()))
sourceDy = ColumnDataSource(data=dict(x=timestamp, y=sketchInstances))
plot.line('x',
'y',
source=sourceDy,
line_alpha=1,
color=Bokeh5[0],
line_width=3,
legend_label="DyBin")
# Hoedd
#
# Hoeffding_dy = ut_gen.genListHoeffdingBin(instances=list(instances_nor[0].ravel()), timestamp=timestamp,
# windowSize=windowSize, initialBin=5)
# sourceHoeffding = ColumnDataSource(data=dict(x=timestamp, y=Hoeffding_dy["sketchInstances"]))
# plot.line('x', 'y', source=sourceHoeffding, line_alpha=1, color=Bokeh5[1], line_width=3,
# legend_label="Hoeffding")
# PAA
data_PAA = ut_gen.genListPAA(instances_nor=instances_nor,
timestamp=timestamp,
windowSize=windowSize)
sourcePAA = ColumnDataSource(
data=dict(x=data_PAA['timestamp'], y=data_PAA['sketchInstances']))
plot.line('x',
'y',
source=sourcePAA,
line_alpha=1,
color=Bokeh5[2],
line_width=3,
legend_label="PAA")
# SAX
data_SAX = ut_gen.genListSAX(instances_nor=instances_nor,
timestamp=timestamp,
windowSize=windowSize,
n_sax_symbols=25)
sourceSAX = ColumnDataSource(
data=dict(x=data_SAX['timestamp'], y=data_SAX['sketchInstances']))
plot.line('x',
'y',
source=sourceSAX,
line_alpha=1,
color=Bokeh5[3],
line_width=3,
legend_label="SAX")
# 1D-SAX
data_1DSAX = ut_gen.genList1D_SAX(instances_nor=instances_nor,
timestamp=timestamp,
windowSize=windowSize)
source1DSAX = ColumnDataSource(
data=dict(x=data_1DSAX['timestamp'], y=data_1DSAX['sketchInstances']))
plot.line('x',
'y',
source=source1DSAX,
line_alpha=1,
color=Bokeh5[4],
line_width=3,
legend_label="1D-SAX")
if add_on:
for row in add_on:
if row["type"] == "anwser":
start_point = timestamp[row["start"]]
end_point = timestamp[row["end"]]
plot = ut_bok.plotAnswerBox(plot=plot,
start_point=start_point,
end_point=end_point)
plot.legend.border_line_width = 3
plot.legend.click_policy = "hide"
plot.legend.border_line_color = "navy"
plot.legend.border_line_alpha = 0.
plot.xaxis.axis_label_text_font_size = "16pt"
plot.xaxis.major_label_text_font_size = "13pt"
plot.yaxis.axis_label_text_font_size = "16pt"
plot.yaxis.major_label_text_font_size = "13pt"
js, div = components(plot)
return js, div
