def sample():
# 加载模型需要的词典、字典
dictionary_path = os.path.join('Dictionary', 'converter.pkl')
if os.path.exists(dictionary_path):
converter = TextConverter(dictionary_path) # 创建对象
print('词典、词表加载完成！')
else:
converter = TextConverter() # 创建对象
converter.save_to_file(dictionary_path) # 将词典保存到磁盘
print('词典、词表创建完成！')
# 更新模型参数路径
if os.path.isdir(Flags.checkpoint_path):
Flags.checkpoint_path = tf.train.latest_checkpoint(Flags.checkpoint_path)
# 创建对象lstm
lstm = LSTM(sampling=True, n_classes=converter.vocab_size(), n_inputs=Flags.n_inputs,
lstm_size=Flags.lstm_size, n_layers=Flags.n_layers)
# 加载模型参数
lstm.load(Flags.checkpoint_path)
# 将起始输入转化为数组
start_string_arr = []
for i in Flags.start_string:
start_string_arr.append(converter.word_to_int(i))
# print(start_string_arr)#[3535, 3390]
# 通过起始字符串返回模型预测的数组
text_arr = lstm.sample(Flags.max_length, start_string_arr, converter)
out_put = [converter.int_to_word_table[i] for i in text_arr]
print(''.join(out_put))
def trainModel(df):
df.shape = (int(22500 / 10), 10, 2)
nn = LSTM(10, 2, 22500)
for i in range(20):
out = "Iteration " + str(i)
print(out)
nn.train(df)
yhat = nn.score(df)
df.shape = (22500, 2)
def run(args):
for mt in testModels3:
import LSTM
model = mt[0]
test = mt[1]
print(test)
if len(mt) == 3:
args.sequence_size = mt[2]
args.test = test
LSTM.main(args, model)
def prepare_data_simple(df):
normalize_DTG(df)
data = df[NAMES].values
#denormalize_DTG_np_nd(data)
#print(data[:10])
#print(df[:10])
x, y = LSTM.getSeriesData(data, WINDOWSIZE, elementdim=data.shape[1])
training_x, validation_x, test_x = LSTM.split_data(x,
val_size=0.0,
test_size=0.0)
training_y, validation_y, test_y = LSTM.split_data(y,
val_size=0.0,
test_size=0.0)
return training_x, training_y, validation_x, validation_y, test_x, test_y
def runLstm(self,text,smooth_flag,percentage):
try:
self.progressBar['maximum']=100
percentage=percentage/100
#timeSeries
timeSeries.run_time_series(text,smooth_flag)
time.sleep(3)
lock.acquire()
#LSTM
#returns date and time dictionary(dt_dic),predictions(pred) and size of prediction
dt_dic,pred,size_of_prediction=LSTM.main_pred(text,percentage,self.progressBar)
lock.release()
self.dt_dic=dt_dic
self.pred=pred
self.size_of_prediction=size_of_prediction
return
except:
print("Error on Lstm !\n")
self.progressBar['value']=0
messagebox.showerror("error","Error in lstm ,please try again")
return
def runGraph(self):
encoderCell = LSTM.Cell()
hiddenState = encoderCell.calculateStates()
prevHiddenState, prevCellState = self.initializeStates()
sess = tf.Session()
init = tf.global_variables_initializer()
init = tf.
sess.run(init)
hasMoreBatch = True
while hasMoreBatch:
try:
currentBatch = next(self.batchGen)
embeddedInput = tf.nn.embedding_lookup(self.embeddingMatrix, currentBatch)
for sentence in embeddedInput:
feedDict = {encoderCell.input: sentence, encoderCell.prevCellState: prevCellState,
encoderCell.prevHiddenState: prevHiddenState}
prevHiddenStateForSample = sess.run([hiddenState], feed_dict=feedDict)
print(prevHiddenStateForSample)
hasMoreBatch = False
except:
hasMoreBatch = False
print("Run out of batches !")
def get_model(model, Title):
embedding_dim = len(Title.vocab.vectors[0])
embedding_weight = Title.vocab.vectors
if model == 'TextCNN':
model = TextCNN.TextCNN(max_length=20,
vocab_size=len(Title.vocab),
embedding_dim=embedding_dim,
embedding_weight=embedding_weight,
output_size=10)
elif model == 'LSTM':
model = LSTM.LSTM(vocab_size=len(Title.vocab),
embedding_dim=embedding_dim,
embedding_weight=embedding_weight,
hidden_size=100,
num_layers=4,
output_size=10)
elif model == 'BiLSTM_Attention':
model = BiLSTM_Attention.BiLSTM_Attention(
vocab_size=len(Title.vocab),
embedding_dim=embedding_dim,
embedding_weight=embedding_weight,
hidden_size=100,
num_layers=4,
output_size=10)
else:
model = Fasttext.fasttext(vocab_size=len(Title.vocab),
embedding_dim=embedding_dim,
embedding_weight=embedding_weight,
hidden_size=100,
output_size=10)
return model
def getLoss(p):
parmDict['epochs'] = p[0]
parmDict['batchSize'] = p[1]
parmDict['L1size'] = p[2]
parmDict['optimizer'] = p[3]
parmDict['activation'] = p[4]
return LSTM.run(trainX, trainY, testX, testY, parmDict)
def do_train_rnn(training_x,
training_y,
validation_x,
validation_y,
name,
plot=False,
fname=None):
print('%s -- TRAINING: %d, VALIDATION: %d' %
(name, training_x.shape[0], validation_x.shape[0]))
idx = NAMES.index(name)
training_y = training_y[:, [idx]]
validation_y = validation_y[:, [idx]]
if name == 'BRAKE':
training_y = onehot(2, training_y)
validation_y = onehot(2, validation_y)
output_dim = 2
else:
output_dim = 1
lstm = LSTM.LSTM(INPUT_DIM, WINDOWSIZE, HIDDEN_NODES, output_dim)
lstm.set_name('lstm_%s_%s.net' % (fname, name))
#lstm.set_validation_data(validation_x, validation_y, valid_stop=0.0002 if name=='Brake' else 0.0005)
nn_loaded = lstm.load()
if not nn_loaded:
lstm.set_training_stop(0.00015)
training_acc, valid_acc = lstm.run(training_x,
training_y,
epochs=4000,
batch_size=200)
lstm.save()
return lstm
def __init__(self, dropout, recurrent_dropout, input_dim, hidden_dim):
super(Siamese, self).__init__()
self.bidir = Bidirectional(LSTM(hidden_dim,
return_sequences=False,
dropout=dropout,
recurrent_dropout=recurrent_dropout),
input_shape=(None, input_dim))
def lstm_with_sin_cos():
NUM_DATA = 1200
orgdata = np.linspace(0, 40, NUM_DATA, dtype=np.float32)
sindata = np.sin(orgdata) + 0.1
cosdata = np.cos(orgdata) * 2
merge = np.stack((sindata, cosdata), axis=-1)
print(merge[:3])
train, validation, test = DATA.split_data(merge)
WINDOWSIZE = 40
train_x, train_y = DATA.getSeriesData(train, WINDOWSIZE, elementdim=2)
valid_x, valid_y = DATA.getSeriesData(validation, WINDOWSIZE, elementdim=2)
test_x, test_y = DATA.getSeriesData(test, WINDOWSIZE, elementdim=2)
print('TRAIN', train.shape)
print('TEST', test.shape)
print('TRAIN X', train_x.shape)
print('TRAIN Y', train_y.shape)
lstm = LSTM.LSTM(2, WINDOWSIZE, 2, 2, loss='square', opt='adam')
lstm.set_validation_data(valid_x, valid_y, valid_stop=0.0001)
lstm.run(train_x,
train_y,
batch_size=int(train_x.shape[0] / 20),
epochs=1000)
lstm.do_test(test_x, test_y)
predict_y = lstm.predict(test_x)
chart = PLOT.LineChart()
chart.scatter(test_y[:, 0], test_y[:, 1], 'g', 'Actual')
chart.scatter(predict_y[:, 0], predict_y[:, 1], 'r', 'ByNN')
chart.show()
def lstm_stock(fname):
df = pd.read_csv(fname, header=0)
print(df.columns)
MAX_PRICE = df.Open.max()
print('MAX_PRICE', MAX_PRICE)
df = df[df.Open != 0][['Open']]
df.Open = df.Open / MAX_PRICE
xy = df.as_matrix()
#xy = MinMaxScaler(xy)
train, validation, test = DATA.split_data(xy)
WINDOWSIZE = 60
train_x, train_y = DATA.getSeriesData(train, WINDOWSIZE, elementdim=1)
valid_x, valid_y = DATA.getSeriesData(validation, WINDOWSIZE, elementdim=1)
test_x, test_y = DATA.getSeriesData(test, WINDOWSIZE, elementdim=1)
print('TRAIN', train.shape)
print('TEST', test.shape)
print('TRAIN X', train_x.shape)
print('TRAIN Y', train_y.shape)
lstm = LSTM.LSTM(1, WINDOWSIZE, 4, 1, loss='square', opt='adam')
lstm.set_validation_data(valid_x, valid_y, valid_stop=0.0001)
lstm.run(train_x,
train_y,
batch_size=int(train_x.shape[0] / 20),
epochs=1000)
lstm.do_test(test_x, test_y)
predict_y = lstm.predict(test_x)
chart = PLOT.LineChart()
chart.line(test_y[:, 0] * MAX_PRICE, 'Actual')
chart.line(predict_y[:, 0] * MAX_PRICE, 'ByNN')
chart.show()
def __init__(self, x_size, y_size, learn_rate, seq_len, expected_out):
self.x = np.zeros(x_size)
self.x_size = x_size
self.y = np.zeros(y_size)
self.y_size = y_size
# information floating out of LSTM cell(hiddenState, cellState, outputState)
self.hsArray = np.zeros((seq_len + 1, y_size))
self.csArray = np.zeros((seq_len + 1, y_size))
self.osArray = np.zeros((seq_len + 1, y_size))
# information about gates(forgot, input, output, cellState) inside LSTM cell
self.fArray = np.zeros((seq_len + 1, y_size))
self.iArray = np.zeros((seq_len + 1, y_size))
self.oArray = np.zeros((seq_len + 1, y_size))
self.cArray = np.zeros((seq_len + 1, y_size))
# weight matrix
self.w = np.random.random((y_size, y_size))
self.G = np.zeros_like(self.w)
# common parameters
self.learn_rate = learn_rate
self.seq_len = seq_len
self.expected_out = np.vstack((np.zeros((1, x_size)), expected_out))
self.LSTM = ls.LSTM(x_size, y_size, learn_rate, seq_len)
def __init__(self, dropout, recurrent_dropout, input_dim, hidden_dim):
super(Siamese, self).__init__()
self.bidir = Bidirectional(LSTM(hidden_dim,
return_sequences=False,
dropout=dropout,
recurrent_dropout=recurrent_dropout),
input_shape=(None, input_dim))
self.zeros = tf.constant(np.zeros(GLOVE_EMBEDDING_DIM), tf.float32)
def train():
model_path = os.path.join('model')
# 如果文件夹不存在，创建文件夹
if os.path.exists(model_path) is False:
os.makedirs(model_path)
# 生成或者加载模型需要的词典、字典
dictionary_path = os.path.join('Dictionary', 'converter.pkl')
if os.path.exists(dictionary_path):
converter = TextConverter(dictionary_path) # 创建对象
print('词典、词表加载完成！')
else:
converter = TextConverter() # 创建对象
converter.save_to_file(dictionary_path) # 将词典保存到磁盘
print('词典、词表创建完成！')
# 打开训练集数据，将text文本转化为数组,形如[1,4,5,,67,3]
trainData_path = os.path.join('trainData', '时间简史.pkl')
if os.path.exists(trainData_path):
with open(trainData_path, 'rb') as f:
text_arr = pickle.load(f)
print("训练数据加载完成！")
else:
text_arr = data_loader(Flags.filePath, converter)
with open(trainData_path, 'wb') as f:
pickle.dump(text_arr, f)
print('训练数据读取并固化完成！')
# batch_generator，输出x,y数据shape=[batch_size, n_steps, n_inputs]
g = batch_generator(text_arr, Flags.batch_size, Flags.n_steps, Flags.n_inputs,
converter.vocab_size(), Flags.window_size, converter=converter)
# 创建对象lstm
lstm = LSTM(sampling=False,
n_classes=converter.vocab_size(),
n_steps=Flags.n_steps,
n_inputs=Flags.n_inputs,
lstm_size=Flags.lstm_size,
n_layers=Flags.n_layers,
keep_prob=Flags.keep_prob,
batch_size=Flags.batch_size,
learning_rate=Flags.learning_rate,
)
lstm.train_model(batch_generator= g, epoches=Flags.epoches)
def lstm_predict(company: str, verbose=False, train_size=0.80, scaled=False):
X_train, X_test, y_train, y_test, prices, times = get_features(company, train_size=train_size, scaled=scaled)
X_train, y_train, X_test, y_test = LSTM_data_prep(X_train, y_train, X_test, y_test)
LSTM_predictions, true_labels = LSTM.predict(X_train, y_train, X_test, y_test, company)
accuracy = accuracy_score(true_labels, LSTM_predictions)
if verbose:
print("LSTM Accuracy: " + str(accuracy * 100) + "%")
prediction_distribution(LSTM_predictions, true_labels)
return prices, times, LSTM_predictions, accuracy
def __init__(self, x_size, y_size, rl, expOut, learnRate):
self.x = np.zeros(x_size)
self.xs = x_size
self.y = np.zeros(y_size)
self.ys = y_size
self.w = np.random.random((y_size, y_size))
self.G = np.zeros_like(self.w)
self.rl = rl
self.lr = learnRate
self.ia = np.zeros((rl + 1, x_size))
self.ca = np.zeros((rl + 1, y_size))
self.oa = np.zeros((rl + 1, y_size))
self.ha = np.zeros((rl + 1, y_size))
self.af = np.zeros((rl + 1, y_size))
self.ai = np.zeros((rl + 1, y_size))
self.ac = np.zeros((rl + 1, y_size))
self.ao = np.zeros((rl + 1, y_size))
self.eo = np.vstack((np.zeros(expOut.shape[0]), expOut.T))
self.LSTM = LSTM(x_size, y_size, rl, learnRate)
def timeseries_for_onetrip(df, s1, s2, window_size):
# print(df.loc[s1].SEQ, df.loc[s2-1].SEQ, df.loc[s2].SEQ)
onetrip = df[s1:s2][['SP', 'RPM', 'BRAKE', 'X', 'Y',
'ROAD_EV']].as_matrix()
# print(onetrip[0], onetrip[-1])
#print(onetrip.shape, s2 - s1)
x, y = LSTM.getSeriesData(onetrip,
window_size,
elementdim=onetrip.shape[1])
#x, y = LSTM.getInBetweenData(onetrip, window_size, elementdim=onetrip.shape[1])
return x, y
def evaluate_classification(model, session, hotel_dict, hotel_to_index_dict,
n_features, hotels_window):
line_tensor = lstm.session_to_tensor_ultimate(session, hotel_dict,
n_features, hotels_window)
output = model(line_tensor)
output = recommendations_from_output_classification(
output, hotel_to_index_dict, hotels_window, n_features)
return output
def train(data):
loss_func = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.01)
for epoch in range(EPOCHS):
running_loss = 0
step = 0
iter_data = data
for sentence, tags in iter_data:
step = step + 1
model.zero_grad()
sentence_in = lstm.prepare_sequence(sentence, word2idx)
targets = lstm.prepare_sequence(tags, label2idx)
pre = model(sentence_in)
loss = loss_func(pre, targets)
running_loss = running_loss + float(loss)
loss.backward()
optimizer.step()
if step % 100 == 0:
print('loss', float(loss))
print('epoch:', epoch, end='')
print('running loss is:', running_loss)
def __init__(self, device): self.device = device self.filePath = os.getcwd() self.target_index = 0 self.num_features = 2 self.batch_size = 64 self.time_window = 60 self.forecast_window = 1 self.year_length = 5 self.train_proportion = 0.8 # best parameters: hidden-50, layer-4, learn-0.01 self.input_dim = self.num_features self.hidden_dim = 50 self.layer_dim = 4 self.output_dim = self.forecast_window self.learning_rate = 0.01 self.num_epochs = 100 self.model = LSTM(input_dim=self.input_dim, hidden_dim=self.hidden_dim, layer_dim=self.layer_dim, output_dim=self.output_dim, batch_size=self.batch_size, stateful=False, device=device).to(self.device)
def _setQ(self, rs, stateSize, nActions):
self.Q = []
if not self.sess:
self.sess = tf.Session()
for i in range(rs):
(self.Q).append(
lstm.LSTM(stateSize,
_defRnnSize,
nActions,
self.agent.livePar.neuralLearningRate,
session=self.sess))
def startTrainingLSTM(self):
cellcount = 20 #задаем количество ячеек LSTM
learningrate = self.ent_learningrate_LSTM.get() #задаем коэффициент обучения
number_epochs = self.ent_number_epochs_LSTM.get() #количество эпох
self.lstm = LSTM.LSTM(cellcount, float(learningrate))
self.lstm.weigths_print()
number_samples = self.ent_number_samples_LSTM.get() # ввели количество строк для обучения
if (number_samples.isdigit()):
print(int(number_samples))
if (int(number_samples) <= self.total_count_LSTM): # нельзя обучить на большем числе примеров, чем есть
self.lstm.train_all(self.data_list_LSTM, int(number_samples), int(number_epochs))
self.lstm.weigths_print()
print("Обучение закончено!")
def Train(x,
y,
model=None,
epochs=100,
batch_size=128,
LR=0.001,
n_layers=3,
layer_size=128,
filters=32,
dropout=False,
MaxPooling=False,
Embedding=False,
vocab_size=None,
embedding_dim=64,
loss="binary_crossentropy",
train=False):
if model == None:
print("Please define the model: [CNN,DNN,RNN,GRU,LSTM,Transformer]")
elif model == "CNN":
Trained_Model = CNN.Train(x, y, epochs, batch_size, LR, n_layers,
filters, dropout, MaxPooling, Embedding,
vocab_size, embedding_dim, loss, train)
elif model == "DNN":
Trained_Model = DNN.Train(x, y, epochs, batch_size, LR, n_layers,
layer_size, dropout, MaxPooling, Embedding,
vocab_size, embedding_dim, loss, train)
elif model == "RNN":
Trained_Model = RNN.Train(x, y, epochs, batch_size, LR, n_layers,
layer_size, dropout, MaxPooling, Embedding,
vocab_size, embedding_dim, loss, train)
elif model == "GRU":
Trained_Model = GRU.Train(x, y, epochs, batch_size, LR, n_layers,
layer_size, dropout, MaxPooling, Embedding,
vocab_size, embedding_dim, loss, train)
elif model == "LSTM":
Trained_Model = LSTM.Train(x, y, epochs, batch_size, LR, n_layers,
layer_size, dropout, MaxPooling, Embedding,
vocab_size, embedding_dim, loss, train)
elif model == "Transformer":
Trained_Model = Transformer.Train(x,
y,
epochs,
batch_size,
LR,
vocab_size,
loss,
embedding_dim,
train=True)
return Trained_Model
def lstm_predict_live_data(company: str, verbose=False, scaled=False):
features, garbage, labels, garbage, garbage, garbage = get_features(company, train_size=1.00, scaled=scaled)
live_features, live_labels, live_prices, live_times = get_live_features(company)
if len(shape(features)) < 3:
features, labels, live_features, live_labels = LSTM_data_prep(features, labels, live_features, live_labels)
print(shape(features))
print(shape(labels))
print(shape(live_features))
print(shape(live_labels))
true_labels, LSTM_predictions = LSTM.predict(features, labels, live_features, live_labels, company)
accuracy = accuracy_score(true_labels, LSTM_predictions)
if verbose:
print("LSTM Accuracy: " + str(accuracy * 100) + "%")
prediction_distribution(LSTM_predictions, true_labels)
return live_prices, live_times, LSTM_predictions, accuracy
def main():
parser = argparse.ArgumentParser(
description="Chainer Anomary Detection by LSTM")
parser.add_argument("--model_path", default="result/snapshot_iter_1130")
parser.add_argument("--keypoints_path", default="test.sav")
parser.add_argument("--lookback_len", default=20)
parser.add_argument("--pred_len", default=5)
args = parser.parse_args()
model = L.Classifier(LSTM.LSTM())
# serializers.load_npz(args.model_path, model)
# with open(args.keypoints_path, "rb") as f:
# keypoints = pickle.load(f)
list = [i for i in range(11)]
it = Iterator(list, 3, 1)
print(iter.__next__())
detector = AnomaryDeteciton(model=model, iterator=it)
def getGraphsOther():
return html.Div(
id='other-graphs',
className='container-fluid',
children=[
# html.Div(className='row', children=[
# html.Div(LassoFunction('A')),
# ]),
# html.Div(className='row', children=[
# html.Div(PyTorch('A')),
# ]),
html.Div(
className='row',
children=[
html.Div(LSTM(13, 640, 340, 330, work,
'W')) # 7day interval
]),
])
def main():
df_dict, df_def = Quandl.load_forex_data()
# Model parameters
features = []#['SandP','TBill','BollingerLower','BollingerMiddle','BollingerUpper','RSI','MA10','EMA12','EMA26','MACD']
targets = ['Value']
# Data hyperparams
time_steps = 365 # How far back are we looking?
# LSTM hyperparams
hidden_size = 5 # How many outputs from the LSTM layer itself, which will then pass thorugh a linear layer?
num_layers = 1 # How many LSTM layers?
dropout = 0.2 # If we have multiple layers, what rate are we applying dropout?
# Training hyperparams
num_epochs = 500
loss = 'MSE' # Huber, KL-Div, MAE, MSE,
optimizer = 'Adam' # SGD, RMSProp
# learning Rate
# Momentum
# weight decay
# Regularization
# Weight Initialization
run_history = {}
# For each data, load and manipulate the data, then train an lstm
for i, df in enumerate(df_dict):
print('Predicting '+df_def[df])
print('')
lstmModel = LSTM.LSTM(data=df_dict[df], features=features, targets=targets, df_name=df, title=df_def[df])
lstmModel.load()
lstmModel.create(hidden_size, num_layers, dropout)
lstmModel.train(loss, optimizer, num_epochs)
lstmModel.visualize_train()
lstmModel.visualize_error()
run_history[i] = lstmModel
print('')
print('')
print('')
def __init__(self):
self.__seerCODataMap_ = {}
self.__villCODataMap_ = {}
self.__wolfCODataMap_ = {}
self.__possCODataMap_ = {}
self.__playerDataMap_ = {}
self.__talkNumMap_ = {}
self.__talkAllNumMap_ = {}
self.__voteMap_ = {}
self.__resultMap_ = {}
self.__voteNum_ = {}
#AliveAgent
self.__aliveAgentList_ = []
self.__aliveAgentIndexList_ = []
self.__agentList_ = []
self.__agentIndexList_ = []
self.__attackedAgentList_ =[]
self.__executedAgentList_ =[]
self.__voteTable_ = {}
self.__today_ = 0
self.__playerNum_ = 0
self.__isCOCall_ = False
self.__isDivineCall_ = False
self.__isOneTimeCall_ = False
#RequestData
self.__requestData_ = []
self.gameInfo = None
self.turn = 0
self.logTurn = -1
self.pred = LSTM.Predictor_05()
self.SaveLog = sv.SaveLog_05()
self.rank = []
self.wolfWinrate = []
self.villWinrate = []
self.calc_flag = False
def execute(self):
self.pushButton.setText("Prediction is running")
self.pushButton.setEnabled(False)
QtGui.QGuiApplication.processEvents()
predictedValue = LSTM.trainTestAndPredict(
self.dateToPredict.date().addDays(-60).toPyDate(),
self.dateToPredict.date().toPyDate(),
str(self.stockPrice.currentText()).split()[0], self.getDays())
#predictedValue = MLP.trainTestAndPredict(self.dateToPredict.date().addDays(-60).toPyDate(), self.dateToPredict.date().toPyDate(),
# str(self.stockPrice.currentText()).split()[0], self.getDays())
monteCarloSimulation(str(self.stockPrice.currentText()).split()[0])
self.predictedLabel.setText(str(predictedValue))
if self.radioButton.isChecked(): self.showHistoryGraph()
else: self.showMonteCarloGraph()
self.pushButton.setText("Predict")
self.pushButton.setEnabled(True)