def train_evalnet(self, evalnet, X, Y):
print("Evaluation network data size: %d" % X.size(0))
dataset = torch.utils.data.TensorDataset(X, Y)
dataloader = torch.utils.data.DataLoader(dataset, batch_size=8, shuffle=True)
epochs = 200
lossf = torch.nn.MSELoss()
optim = torch.optim.SGD(evalnet.parameters(), lr=0.01, momentum=0.9)
sched = torch.optim.lr_scheduler.MultiStepLR(optim, milestones=[80, 160])
bar = tqdm.tqdm(range(epochs), ncols=80)
avg = MovingAverage(momentum=0.95)
for epoch in bar:
for Xb, Yb in dataloader:
Xb = self.create_normal(Xb)
Yb = self.create_normal(Yb)
Yh = evalnet(Xb).squeeze()
loss = lossf(Yh, Yb)
full_loss = loss + self.grad_penalty(evalnet, X, Xb)
optim.zero_grad()
full_loss.backward()
optim.step()
sched.step()
avg.update(loss.item())
bar.set_description("Fitting evalnet: %.3f" % avg.peek())
def __init__(self, args):
input_path = args['input']
if not os.path.exists(input_path):
raise FileNotFoundError(f'{input_path} does not exist')
# get capture object
self.cap = self.get_video(input_path)
# get total number of frames
self.total_frames = int(self.cap.get(cv2.CAP_PROP_FRAME_COUNT))
# get buffer size
self.buffer_size = args['buffer']
# handle size parameter
self.handle_size(args['size'])
# get name of file
filename = self.get_filename(input_path)
# get output
output = args['output']
# get final dir
self.output_dir = output + filename + '/'
# create dictionary of video writers
self.input_videos = {}
self.video_writers = {}
# determine options for program
self.handle_option(args['option'], args['read'])
# initiate average and edit class
self.stabiliser = Stabiliser(self.total_frames, self.size)
self.ma = MovingAverage(self.size, False, False, args['buffer'])
self.fe = FrameEditor()
self.plt = Plotter(self.output_dir)
# creates background model class using mixture of gradients
self.backSub = cv2.createBackgroundSubtractorMOG2()
def __init__(self, D):
super().__init__(D)
self.target_modules = [torch.nn.Linear]
self.gain_rate = 0.01
self.loss_rate = 0.05
self.epochs = 100
self.batch = 8
self.score = MovingAverage(momentum=0.90)
self.train_score = MovingAverage(momentum=0.9)
def __init__(self, data, fastType, fastWindow, fastGradWindow, slowType,
slowWindow, slowGradWindow, spreadGradWindow):
self.data = data.fillna(method='bfill', axis=1)
self.x = self.data[self.data.columns[0]].tolist()
self.dates = self.data.index.tolist()
self.height = len(self.data)
self.spreadGradWindow = spreadGradWindow
self.TodayStatics = {}
self.slowType = slowType
self.slowWindow = slowWindow
self.slowGradWindow = slowGradWindow
self.slowMAObj = MovingAverage(self.data,
self.slowType,
slowWindow,
gradWindow=slowGradWindow)
self.slowMA = self.slowMAObj.data['MA'].tolist()
self.fastType = fastType
self.fastWindow = fastWindow
self.fastGradWindow = fastGradWindow
self.fastMAObj = MovingAverage(self.data,
self.fastType,
fastWindow,
gradWindow=fastGradWindow)
self.fastMA = self.fastMAObj.data['MA'].tolist()
self.tradeSignal = self.CalcCrossOverScore()
self.spread = self.CalcSpread()
self.CalcSpreadGradient() # This will set all gradient data
self.tradeDaySeries = self.CalcTradeDaySeries()
self.TodayStatics['todayMAslow'] = self.slowMA[
-1] # today's level of the slow MA
self.TodayStatics['todayMAfast'] = self.fastMA[
-1] # today's level of the fast MA
self.TodayStatics['todayCrossScore'] = self.tradeSignal[-1]
self.TodayStatics['todaySpread'] = self.spread[-1]
self.TodayStatics['todayTradeDays'] = self.tradeDaySeries[-1]
self.preCrossOver = self.CalcLastCrossOver()
self.CalcTradeDayZscores() # Calc Z-score of Trading days
if (fastWindow > slowWindow):
raise Exception('Parameter Error : fast MA is larger than slow MA')
self.CalcHiLoInCurrentTrade(
) # calculate the price hilo during current trade
class LowLightEnhancer:
"""A class for enhancing low light video files
The LowLightEnhancer class is used to enhance low light video using a logarithmic expansion of frames averaged over some buffer size
"""
def __init__(self, args):
input_path = args['input']
if not os.path.exists(input_path):
raise FileNotFoundError(f'{input_path} does not exist')
# get capture object
self.cap = self.get_video(input_path)
# get total number of frames
self.total_frames = int(self.cap.get(cv2.CAP_PROP_FRAME_COUNT))
# get buffer size
self.buffer_size = args['buffer']
# handle size parameter
self.handle_size(args['size'])
# get name of file
filename = self.get_filename(input_path)
# get output
output = args['output']
# get final dir
self.output_dir = output + filename + '/'
# create dictionary of video writers
self.input_videos = {}
self.video_writers = {}
# determine options for program
self.handle_option(args['option'], args['read'])
# initiate average and edit class
self.stabiliser = Stabiliser(self.total_frames, self.size)
self.ma = MovingAverage(self.size, False, False, args['buffer'])
self.fe = FrameEditor()
self.plt = Plotter(self.output_dir)
# creates background model class using mixture of gradients
self.backSub = cv2.createBackgroundSubtractorMOG2()
def release_video(self):
for writer in self.video_writers.values():
writer.release()
def handle_size(self, size):
if size != None:
self.size = tuple(args.size[1], args.size[0])
else:
# get caps original size
self.size = (int(self.cap.get(4)), int(self.cap.get(3)))
def get_filename(self, path):
path_split = path.split('/')
filename = path_split[-1].split('.')[0]
return filename
def handle_option(self, opt, read):
if not os.path.exists(self.output_dir):
os.mkdir(self.output_dir)
cur_filename = self.output_dir + "input30.mp4"
self.video_writers["input"] = self.create_vwriter(cur_filename)
for char in opt:
if char == 's':
cur_filename = self.output_dir + "stable.mp4"
if read:
cap = self.get_video(cur_filename)
if cap:
print("input found")
self.input_videos["stable"] = cap
continue
self.video_writers["stable"] = self.create_vwriter(
cur_filename)
elif char == 'e':
cur_filename = self.output_dir + "expand.mp4"
if read:
cap = self.get_video(cur_filename)
if cap:
print("input found")
self.input_videos["expand"] = cap
continue
self.video_writers["expand"] = self.create_vwriter(
cur_filename)
elif char == 'm':
cur_filename = self.output_dir + "motion.mp4"
if read:
cap = self.get_video(cur_filename)
if cap:
print("input found")
self.input_videos["motion"] = cap
continue
self.video_writers["motion"] = self.create_vwriter(
cur_filename)
elif char == 'c':
cur_filename = self.output_dir + "closure.mp4"
if read:
cap = self.get_video(cur_filename)
if cap:
print("input found")
self.input_videos["closure"] = cap
continue
self.video_writers["closure"] = self.create_vwriter(
cur_filename)
elif char == 'a':
cur_filename = self.output_dir + "average.mp4"
self.video_writers["average"] = self.create_vwriter(
cur_filename)
cur_filename = self.output_dir + "contribution.mp4"
self.video_writers["contribution"] = self.create_vwriter(
cur_filename)
def create_vwriter(self, filename):
# set codec for written video
fourcc = cv2.VideoWriter_fourcc(*"mp4v")
fps = int(self.cap.get(cv2.CAP_PROP_FPS))
video_writer = cv2.VideoWriter(filename, fourcc, fps, self.size[::-1])
return video_writer
def get_video(self, path):
cap = cv2.VideoCapture(path)
if not cap.isOpened():
print("No Video Found")
return None
else:
return cap
def enough_frames(self):
return True
def enhance(self):
"""Read video, perform enhancement, & write enhanced video to file
"""
# first pass
print("first pass")
if "stable" not in self.input_videos and "stable" in self.video_writers:
for i in tqdm(range(self.total_frames)):
# Capture frame-by-frame
ret, frame = self.cap.read()
# check capture
if not ret:
print("video finished")
break
self.stabiliser.get_transform(frame, i)
# stabilise
traj, smooth = self.stabiliser.get_trajectory()
# plot trajectorys
self.plt.plot_trajectory(traj, smooth)
# Reset stream to first frame
self.cap.set(cv2.CAP_PROP_POS_FRAMES, 0)
# default mask value
mask_fg = np.ones((self.size), dtype=np.uint8) * 255
finished = False
i = 0
print("second pass")
while not finished:
# Capture frame-by-frame
ret, frame = self.cap.read()
initial = frame
self.video_writers["input"].write(initial)
# check capture
if not ret:
print("video finished")
break
# stablise video
if "stable" in self.video_writers:
stable = self.stabiliser.get_stable_frame(frame, i)
frame = stable
self.video_writers["stable"].write(stable)
# check if reading from file
elif "stable" in self.input_videos:
ret, frame = self.input_videos["stable"].read()
# get foreground mask
if "motion" in self.video_writers:
fg = self.backSub.apply(frame)
_, thresh = cv2.threshold(fg, 127, 255, cv2.THRESH_BINARY_INV)
mask_fg = thresh
# convert to 3 channels for output
mask_fg_3 = cv2.cvtColor(fg, cv2.COLOR_GRAY2BGR)
self.video_writers["motion"].write(mask_fg_3)
if "closure" in self.video_writers:
# threshold and inverse
close = cv2.morphologyEx(mask_fg, cv2.MORPH_CLOSE,
np.ones((3, 3), np.uint8))
close_3 = cv2.cvtColor(close, cv2.COLOR_GRAY2BGR)
self.video_writers["closure"].write(close_3)
mask_fg = close
# Call image operations here passes uint8 gets uint8
if "expand" in self.video_writers:
edit_frame = self.fe.doOperation(frame)
self.video_writers["expand"].write(edit_frame)
frame = edit_frame
# store frame in moving average
if "average" in self.video_writers:
# get stationary contribution from frame
contribution = cv2.bitwise_and(frame, frame, mask=mask_fg)
av_frame = self.ma.add(contribution, mask_fg)
if av_frame is not None:
av_frame = np.uint8(av_frame)
contribution = np.uint8(contribution)
self.video_writers["contribution"].write(contribution)
self.video_writers["average"].write(av_frame)
if self.enough_frames():
self.plt.plot_histogram(initial, "input", True)
cv2.imwrite(self.output_dir + "input_frame" + ".png",
initial)
cv2.imwrite(
self.output_dir + "expanded_frame" + ".png",
edit_frame)
self.plt.plot_histogram(av_frame, "final", True)
cv2.imwrite(self.output_dir + "final_frame" + ".png",
av_frame)
if "motion" in self.video_writers:
cv2.imwrite(self.output_dir + "mask" + ".png",
close_3)
finished = True
i += 1
# key to break playback
if cv2.waitKey(1) & 0xFF == ord('q'):
break
# When everything is done, release the capture
self.release_video()
self.cap.release()
cv2.destroyAllWindows()
def test_MovingAverageComputesCorrectlyForLength3(self):
l = [0, 2, 0]
expected = [2 / 3]
result = MovingAverage().EvenlySpaced(l, 3)
self.assertListEqual(expected, result)
def plotGraph(list_of_list, diagramName='', mvaLength=21):
''' [[xValues],[yValues]]
This Plots all given values and his filtered line.
'''
if not len(list_of_list) % 2 == 0:
raise ArgMismatch('Please provide [[xValues],[yValues], ...] as arguments')
time_start = time.time()
#------------------------------------------------------------------------------
oneHouer = 60 * 60
quater_day = oneHouer * 6
half_a_day = oneHouer * 12
oneDay = oneHouer * 24
oneWeek = oneDay * 7
oneMonth = oneWeek * 4
half_a_Year = oneMonth * 6
one_Year = half_a_Year * 2
tmin = 0
now = time.mktime(time.localtime())
for i in range(0, len(list_of_list), 2):
# ---- Calc filtered values ------
list_length = len(list_of_list[i])
if list_length < mvaLength:
mva = MovingAverage(list_length)
else:
mva = MovingAverage(mvaLength)
for j in range(0, len(list_of_list[i])):
mva.addValue(list_of_list[i][j], list_of_list[i+1][j])
filterd_values = mva.getAverage()
fvTimes = []
fvValues = []
for item in filterd_values:
fvTimes.append(item[0])
fvValues.append(item[1])
# ---- Append org values
dates = [dt.datetime.fromtimestamp(ts) for ts in list_of_list[i]]
datenums = md.date2num(dates)
ax = plt.gca()
xfmt = md.DateFormatter('%Y-%m-%d %H:%M')
ax.xaxis.set_major_formatter(xfmt)
plt.plot(datenums, list_of_list[i + 1], lw=1, color='gray')
# ---- Append filtered values ------
dates = [dt.datetime.fromtimestamp(ts) for ts in fvTimes]
datenums = md.date2num(dates)
tmin = min(datenums)
ax = plt.gca()
xfmt = md.DateFormatter('%Y-%m-%d %H:%M')
ax.xaxis.set_major_formatter(xfmt)
plt.plot(datenums, fvValues, lw=2)
plt.subplots_adjust(bottom=0.2)
plt.xticks(rotation=90)
ax.grid(True)
plt.title(diagramName)
#plt.text(tmin, -300, r'Read')
#plt.text(tmin, +200, r'Write')
plt.xlabel('Time')
plt.ylabel('Speed [MB/s]')
plt.savefig('plt/' + str(diagramName) + '.png')
plt.close('all')
#------------------------------------------------------------------------------
time_end = time.time()
def test_MovingDateAverageWith2DayEvenSpacingLength4(self):
d = {1: 1, 3: 4, 5: 5}
expected = {5: (1 + 4 + 4 + 5) / 4}
result = MovingAverage().ArbitrarySpacing(d, 3)
self.assertEqual(expected, result)
def main():
dates = []
temps = []
with open(CSV_FILENAME, 'r') as csv_file:
r = csv.reader(csv_file, delimiter=',', quotechar='"')
first_row = True
for row in r:
# First row contains csv table header, so we discard it
if first_row:
first_row = False
continue
dates.append(datetime.strptime(row[1], DATETIME_FORMAT))
temps.append(int(row[5]))
averages = list(MovingAverage(temps, MOVING_AVERAGE_WINDOW_SIZE))
"""
Gives us points where the 2 graphs intersect by
checking where the sign of the difference changes
"""
intersections = np.argwhere(np.diff(
np.sign([temps[i] - averages[i] for i in range(len(temps))]))).flatten()
i_dates = []
i_temps = []
for inter in intersections:
"""
No need for a bounds check, since intersection can't happen unless
there's a point following this one that causes the intersection
to take place
"""
vt0 = temps[inter]
vt1 = temps[inter + 1]
slope_temp = vt1 - vt0
va0 = averages[inter]
va1 = averages[inter + 1]
slope_avg = va1 - va0
# Distance from point0 to the intersection point
dist = abs(vt0 - va0) / abs(slope_temp - slope_avg)
# Calculate the actual time and temperature of intersection
time_delta = dates[inter + 1] - dates[inter]
i_date = dates[inter] + time_delta * dist
i_temp = vt0 + slope_temp * dist
print("Průnik nalezen {0:%d. %m. %Y v %H:%M} o teplotě {1}°C".format(
i_date, round(i_temp, 1)))
i_dates.append(i_date)
i_temps.append(i_temp)
plt.plot(dates, temps, 'b-', dates, averages, 'g-', linewidth=1)
plt.plot(i_dates, i_temps, 'r+', mew=2, ms=8)
plt.ylabel('Teplota (°C)')
plt.xlabel('Čas')
plt.title('Průměrná templota v Chodově, Praha')
plt.grid()
plt.show()
def plotJob(timestamps, rbs, rio, wbs, wio, title, verbose):
# convert timestamps
dates1 = [dt.datetime.fromtimestamp(ts) for ts in timestamps]
# calculate filter size
fsize = int(math.sqrt(len(dates1)))
if fsize < 3:
fsize = 3
# claculate filterd values
mvaRB = MovingAverage(fsize)
mvaWB = MovingAverage(fsize)
for i in range(len(timestamps)):
mvaWB.addValue(timestamps[i], wbs[i])
mvaRB.addValue(timestamps[i], rbs[i])
filterd_WB = mvaWB.getAverage()
filterd_RB = mvaRB.getAverage()
WB_Values = []
for item in filterd_WB:
WB_Values.append(item[1])
RB_Values = []
for item in filterd_RB:
RB_Values.append(item[1])
# Write
fig = plt.figure(figsize=(16, 10))
ax1 = fig.add_subplot(2, 3, 1)
plt.xticks(rotation=45)
plt.xlabel('Time')
plt.ylabel('Speed [MB/s]')
ax2 = fig.add_subplot(2, 3, 2)
plt.xlabel('IO Size [KB]')
plt.ylabel('IOs')
#plt.gca().yaxis.set_major_formatter(formatter)
ax3 = fig.add_subplot(2, 3, 3)
plt.ylabel('Speed [MB/s]')
plt.xlabel('IO Size [KB]')
# Read
ax4 = fig.add_subplot(2, 3, 4)
plt.xticks(rotation=45)
plt.xlabel('Time')
plt.ylabel('Speed [MB/s]')
ax5 = fig.add_subplot(2, 3, 5)
plt.xlabel('IO Size [KB]')
plt.ylabel('IOs')
#plt.gca().yaxis.set_major_formatter(formatter)
ax6 = fig.add_subplot(2, 3, 6)
plt.ylabel('Speed [MB/s]')
plt.xlabel('IO Size [KB]')
# Speed
ax1.plot(dates1, wbs, label='Exact Data', lw=1, color='gray')
ax1.plot(dates1, WB_Values, label='Filterd Data', lw=2, color='green')
ax1.set_title('Write MB')
ax1.legend(loc='best')
ax4.plot(dates1, rbs, label='Exact Data', lw=1, color='gray')
ax4.plot(dates1, RB_Values, label='Filterd Data', lw=2, color='blue')
ax4.set_title('Read MB')
ax4.legend(loc='best')
# Histograms
bins1 = 30
# avoid arrays with only one elemet. important!
plot_wio = np.append(wio[wio > 0], 1)
plot_wbs = np.append(wbs[wbs > 0], 1)
plot_rio = np.append(rio[rio > 0], 1)
plot_rbs = np.append(rbs[rbs > 0], 1)
ax2.hist(plot_wio, bins=bins1, color='green')
ax2.set_title('Histogram of Write IO Size')
ax5.hist(plot_rio, bins=bins1, color='blue')
ax5.set_title('Histogram of Read IO Size')
# ------ scatter plots --------
if len(plot_wio) > 1 and len(plot_wbs) > 1:
ax3.hexbin(plot_wio, plot_wbs, bins='log', mincnt=1)
# ax3.scatter(wio, wbs, color='green', s=1)
ax3.set_title('Scatter Plots Write')
if len(plot_rio) > 1 and len(plot_rbs) > 1:
ax6.hexbin(plot_rio, plot_rbs, bins='log', mincnt=1)
#ax6.scatter(rio[rio > 0], rbs[rbs > 0], color='blue', s=1)
ax6.set_title('Scatter Plots Read')
# show data plot
plt.tight_layout()
plt.savefig(str(title) + '.png', dpi=120)
print 'plot to', str(title) + '.png'
#plt.show()
plt.close('all')
df = df[start_time:end_time]
st.dataframe(df)
st.subheader('3.训练集划分')
number = st.number_input("请输入训练集所占比例：",min_value=0.5,max_value=0.9,value=0.8,step=0.1)
split = int(number * len(df))
st.write("选择的数据集大小：",len(df))
st.write("训练集大小：",split)
st.write("预测集大小：",len(df)-split)
st.subheader('4.选择预测目标')
type = st.selectbox('请选择预测目标：',('Close','Turnover'))
st.line_chart(df[type])
st.subheader('5.选择机器学习算法')
genre = st.selectbox("请选择时间序列预测算法",
('移动平均算法', '线性回归算法', '最近邻算法', 'AutoARIMA算法', 'LSTM算法'))
if genre == '移动平均算法':
MovingAverage(df, type, split)
elif genre == '线性回归算法':
LinearRegression(df, type, split)
elif genre == '最近邻算法':
KNearestNeighbours(df, type, split)
elif genre == 'AutoARIMA算法':
AutoARIMA(df, type, split)
elif genre == 'LSTM算法':
LongShortTM(df, type, split)
def __init__(self, StockCode, StartDate, EndDate):
log_txt.insert(INSERT, 'getting price list\n')
try:
df = get_pse_data(StockCode, StartDate, EndDate)
except Exception as e:
log_txt.insert(INSERT, 'Get pse data error: {e}\n'.format(e=e))
log_txt.insert(INSERT, 'price list obtained')
# Derive the 30 day SMA of JFC's closing prices
ma30 = df.close.rolling(30).mean()
ma100 = df.close.rolling(100).mean()
# Combine the closing prices with the 30 day SMA
data = pd.concat([df.close, ma30, ma100], axis=1).dropna()
data.columns = [
'Closing Price', 'Simple Moving Average (30 day)',
'Simple Moving Average (100 day)'
]
#Create a new dataframe
signal = pd.DataFrame(index=df['close'].index)
signal['close'] = data['Closing Price']
signal['SMA30'] = data['Simple Moving Average (30 day)']
signal['SMA100'] = data['Simple Moving Average (100 day)']
log_txt.insert(INSERT, 'calculate RSI\n')
v_RSI = RSI.getRSI(self, signal)
log_txt.insert(INSERT, 'done calculating RSI\n')
log_txt.insert(INSERT, 'calculate moving averages\n')
MA = MovingAverage.buy_sell(signal)
log_txt.insert(INSERT, 'done calculating moving averages\n')
try:
signal['Buy_Signal_Price_MA'] = MA[0]
signal['Sell_Signal_Price_MA'] = MA[1]
signal['Buy_Signal_Price_RSI'] = v_RSI[0]
signal['Sell_Signal_Price_RSI'] = v_RSI[1]
except Exception as e:
log_txt.insert(INSERT,
'Get buy and sell data error: {e}\n'.format(e=e))
# Visually Show The Stock buy and sell signals
# Create the title
title = 'Adj. Close Price History Buy / Sell Signals '
# Get the stocks
my_stocks = signal
ticker = "close"
# Create and plot the graph
try:
plt.figure(figsize=(12.2, 4.5)) # width = 12.2in, height = 4.5
plt.scatter(my_stocks.index,
my_stocks['Buy_Signal_Price_MA'],
color='green',
label='Buy Signal MA',
marker='^',
alpha=1)
plt.scatter(my_stocks.index,
my_stocks['Sell_Signal_Price_MA'],
color='darkred',
label='Sell Signal MA',
marker='v',
alpha=1)
plt.scatter(my_stocks.index,
my_stocks['Buy_Signal_Price_RSI'],
color='blue',
label='Buy Signal RSI',
marker='^',
alpha=1)
plt.scatter(my_stocks.index,
my_stocks['Sell_Signal_Price_RSI'],
color='red',
label='Sell Signal RSI',
marker='v',
alpha=1)
plt.plot(
my_stocks[ticker], label=ticker, alpha=0.35
) # plt.plot( X-Axis , Y-Axis, line_width, alpha_for_blending, label)
plt.plot(my_stocks['SMA30'], label='SMA30', alpha=0.35)
plt.plot(my_stocks['SMA100'], label='SMA100', alpha=0.35)
plt.title(title)
plt.xlabel('Date', fontsize=18)
plt.ylabel('Adj. Close Price PHP', fontsize=18)
plt.legend(loc='upper left')
except Exception as e:
log_txt.insert(INSERT, 'Plotting data error: {e}\n'.format(e=e))
try:
plt.show()
except Exception as e:
log_txt.insert(INSERT, 'Plotting data error: {e}\n'.format(e=e))
log_txt.insert(INSERT, 'Produced graph\n')
def test_MovingDateAverageWith2DayEvenSpacing(self):
d = {1: 1, 3: 4, 5: 5}
expected = {3: 5 / 2, 5: 9 / 2}
result = MovingAverage().ArbitrarySpacing(d, 2)
self.assertEqual(expected, result)
TakeProfit.__init__(self, data, tradeSignal)
self.takeProfitRule = takeProfitRule
self.CalcTakeProfitSeries()
def CalcTakeProfitLevel(self, highWaterMark, tradeSignal):
if tradeSignal == 1:
level = highWaterMark * (
1 - (self.takeProfitRule + 0.0) / 100
) # Set the NEW take profit BELOW the market
tpLevel = [level, np.nan]
else:
level = highWaterMark * (
1 + (self.takeProfitRule + 0.0) / 100
) # Set the OLD take profit ABOVE the market
tpLevel = [np.nan, level]
return tpLevel
if __name__ == "__main__":
data = pd.DataFrame([
1.0455, 1.0405, 1.0489, 1.0607, 1.0532, 1.0574, 1.0554, 1.0582, 1.0613,
1.0643, 1.0601, 1.0713, 1.063, 1.0664, 1.0703, 1.0765, 1.0731, 1.0748,
1.0682, 1.0699, 1.0695, 1.0798, 1.0769, 1.0759, 1.0783, 1.075, 1.0683,
1.0698, 1.0655, 1.0643
])
MAWindow = 5
ma = MovingAverage(data, 'EMA', 5)
tradeSignal = ma.TradeSignal
t = TakeProfitFixed(data, tradeSignal, 5)
print t.takeProfitContainer
def test_MovingAverageHasLessElements(self):
values = [1, 2, 3]
ma = MovingAverage().EvenlySpaced(values, 2)
self.assertEqual(len(values), len(ma) + 1)
class EvolutionaryUnit(Model):
def __init__(self, D):
super().__init__(D)
self.target_modules = [torch.nn.Linear]
self.gain_rate = 0.01
self.loss_rate = 0.05
self.epochs = 100
self.batch = 8
self.score = MovingAverage(momentum=0.90)
self.train_score = MovingAverage(momentum=0.9)
def set_device(self, device):
self.device = device
self.to(device)
def __lt__(self, other):
return self.get_score() < other.get_score()
def fit(self, X, Y, X_test, Y_test):
dataset = torch.utils.data.TensorDataset(X, Y)
dataloader = torch.utils.data.DataLoader(dataset,
batch_size=self.batch,
shuffle=True)
lossf = torch.nn.MSELoss()
optim = torch.optim.Adam(self.parameters())
sched = torch.optim.lr_scheduler.MultiStepLR(optim, milestones=[60])
for epoch in range(self.epochs):
self.train()
for x, y in dataloader:
x = x.to(self.device)
y = y.to(self.device)
yh = self(x)
loss = lossf(yh, y)
optim.zero_grad()
loss.backward()
optim.step()
self.train_score.update(self.calc_score(yh, y))
sched.step()
with torch.no_grad():
self.eval()
yh_test = self(X_test.to(self.device))
self.score.update(self.calc_score(yh_test, Y_test.to(self.device)))
def get_score(self):
return self.score.peek() # lower the better
def get_train_score(self):
return self.train_score.peek()
def mutate(self):
out = copy.deepcopy(self)
out.apply(self.recurse_apply(self.gain_ability))
out.apply(self.recurse_apply(self.lose_ability))
return out
def share_abilities(self, other):
n1 = copy.deepcopy(self)
n2 = copy.deepcopy(other)
for m1, m2 in zip(n1.net, n2.net):
self.exchange(m1, m2)
return n1, n2
# === PRIVATE ===
def exchange(self, m1, m2):
if type(m1) in self.target_modules:
p = 0.5
i = torch.rand_like(m1.weight.data) < p
m1.weight.data[i] = m2.weight.data[i]
m2.weight.data[1 - i] = m1.weight.data[1 - i]
def calc_score(self, yh, y):
return (yh - y).abs().sum().item()
def recurse_apply(self, f):
return lambda m: f(m) if type(m) in self.target_modules else None
def gain_ability(self, m):
i, v = self.get_new_weights(m, self.gain_rate)
torch.nn.init.kaiming_uniform_(v, a=math.sqrt(5))
m.weight.data[i] = v[i]
def lose_ability(self, m):
i, v = self.get_new_weights(m, self.loss_rate)
m.weight.data[i] = v[i]
def get_new_weights(self, m, rate):
i = (torch.rand_like(m.weight.data) < rate)
v = torch.zeros_like(m.weight.data)
return i, v
#fname = '.\camera_cal\calibration3.jpg'
#img = cv2.imread(fname)
#
#top_down, perspective_M = cc.corners_unwarp(img, cc.nx, cc.ny, mtx, dist)
#
#f, (ax1, ax2) = plt.subplots(1,2, figsize=(12, 7))
#f.tight_layout()
#ax1.imshow(img)
#ax1.set_title('Original Image')
#ax2.imshow(top_down)
#ax2.set_title('Undistorted and Warped Image')
##plt.subplots_adjust(left=0., right=1, top=0.9, bottom=0.)
#%%
global counter, left_rad_filt, right_rad_filt
left_rad_filt = MovingAverage(8)
right_rad_filt = MovingAverage(8)
left_fit_filt = MovingAverage(6)
right_fit_filt = MovingAverage(6)
counter = 0
def pipeline_image(image, force_first_frame=False, plot_figure=False):
global counter
if force_first_frame:
counter = 1
else:
counter += 1
