def test(args, ckpt_file):
print("========== In the test step ==========")
batch_size = args["batch_size"]
lr = args["learning_rate"]
momentum = args["momentum"]
epochs = args["train_epochs"]
train_split = args["split_train"]
CSV_FILE = "./data/mushrooms.csv"
dataset = MushroomDataset(CSV_FILE)
test_dataset = torch.utils.data.Subset(
dataset, list(range(int(train_split * len(dataset)), len(dataset)))
)
test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)
net = NeuralNet()
net = net.to(device=device)
net.load_state_dict(
torch.load(os.path.join(args["EXPT_DIR"], ckpt_file + ".pth"))["model"]
)
net.eval()
predix = 0
predictions = {}
truelabels = {}
n_val = len(test_dataset)
with tqdm(total=n_val, desc="Testing round", unit="batch", leave=False) as pbar:
for step, (batch_x, batch_y) in enumerate(test_loader):
with torch.no_grad():
batch_x = batch_x.to(device)
batch_y = batch_y.to(device)
prediction = net(batch_x)
for logit, label in zip(prediction, batch_y):
predictions[predix] = logit.cpu().numpy().tolist()
truelabels[predix] = label.cpu().numpy().tolist()
predix += 1
pbar.update()
truelabels_ = []
predictions_ = []
for key in predictions:
if predictions[key][0] > 0.5:
predictions_.append(1)
else:
predictions_.append(0)
for key in truelabels:
truelabels_.append(truelabels[key][0])
truelabels = truelabels_
predictions = predictions_
# print("predictions",predictions)
return {"predictions": predictions, "labels": truelabels}
def ShowResult(net, dataReader, title):
# draw train data
X, Y = dataReader.XTrain, dataReader.YTrain
plt.plot(X[:, 0], Y[:, 0], '.', c='b')
# create and draw visualized validation data
TX = np.linspace(0, 1, 100).reshape(100, 1)
TY = net.inference(TX)
plt.plot(TX, TY, 'x', c='r')
plt.title(title)
plt.show()
if __name__ == '__main__':
dataReader = DataReader(train_data_name, test_data_name)
dataReader.ReadData()
dataReader.GenerateValidationSet()
n_input, n_hidden, n_output = 1, 3, 1
eta, batch_size, max_epoch = 0.5, 10, 10000
eps = 0.001
hp = HyperParameters(n_input, n_hidden, n_output, eta, max_epoch,
batch_size, eps, NetType.Fitting,
InitialMethod.Xavier)
net = NeuralNet(hp, "save")
net.train(dataReader, 50, True)
net.ShowTrainingHistory()
ShowResult(net, dataReader, hp.toString())
# hyperparameter
batch_size = 8
input_size = len(x_train[0])
hidden_size = 8
output_size = len(tags)
learning_rate = 0.001
num_epochs = 1000
dataset = ChatDataset()
train_loader = DataLoader(dataset=dataset,
batch_size=batch_size,
shuffle=True,
num_workers=2)
device = torch.device('cude' if torch.cuda.is_available() else 'cpu')
model = NeuralNet(input_size, hidden_size, output_size)
# loss and optimizer
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)
for epoch in range(num_epochs):
for (words, labels) in train_loader:
words = words.to(device)
labels = labels.to(device)
# forward
outputs = model(words)
loss = criterion(outputs, labels)
optimizer.zero_grad()
loss.backward()
optimizer.step()
if (i + 1) % 10 == 0:
print('Epoch [{}/{}], Step [{}/{}], Loss: {:.4f}'.format(
epoch + 1, 30, i + 1, total_step, loss.item()))
Q_preds = []
Q_targets = []
with torch.no_grad():
for (hour_features, daily_features), labels in test_dataloader:
outputs = model((hour_features, daily_features))
Q_preds.append(outputs.numpy())
Q_targets.append(labels.numpy())
Q_preds = np.array(Q_preds)
Q_targets = np.array(Q_targets)
Q_preds = Q_preds.reshape((-1, 1))
Q_targets = Q_targets.reshape((-1, 1))
print(cv_rmse(torch.from_numpy(Q_preds), torch.from_numpy(Q_targets)))
print(Q_preds[:24])
print(Q_targets[:24])
torch.save(model.state_dict(), 'hournn_' + energy + '.pth')
if __name__ == "__main__":
# train_hour_model('W')
model = NeuralNet(4, 256, 1)
# model = concatNN(20, 256, 3, 1, "add")
train_daily_model('Q', model, "regression")
def get_model(dataset, logger, model_params):
model = NeuralNet(dataset, logger, model_params.dict)
return model
import cv2
import numpy as np
from model import NeuralNet
net = NeuralNet()
# creating a 600 x 600 pixels canvas for mouse drawing
canvas = np.ones((600, 600), dtype="uint8") * 255
# designating a 400 x 400 pixels point of interest on which digits will be drawn
canvas[100:500, 100:500] = 0
start_point = None
end_point = None
is_drawing = False
def draw_line(img, start_at, end_at):
cv2.line(img, start_at, end_at, 255, 15)
def on_mouse_events(event, x, y, flags, params):
global start_point
global end_point
global canvas
global is_drawing
if event == cv2.EVENT_LBUTTONDOWN:
if is_drawing:
start_point = (x, y)
elif event == cv2.EVENT_MOUSEMOVE:
if is_drawing:
end_point = (x, y)
# test_dataset = BF.BreakfastNaive(visual_feat_path_test, text_path_test, map_path)
print("Test set loaded")
print("Dataset size")
print(len(train_dataset))
print(len(test_dataset))
train_loader = torch.utils.data.DataLoader(dataset=train_dataset,
batch_size=batch_size,
shuffle=True)
test_loader = torch.utils.data.DataLoader(dataset=test_dataset,
batch_size=batch_size,
shuffle=False)
# MODEL
model = NeuralNet(input_size, hidden_size, num_classes).to(device)
# Loss and optimizer
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)
# TRAIN
total_step = len(train_loader)
for epoch in range(num_epochs):
correct_predictions = 0
total_predictions = 0
for i, data_batch in enumerate(train_loader):
vis_feats = data_batch['vis_feats'].to(device)
labels = data_batch['labels'].to(
device) # TODO dont send one of them to gpu and see what happens?
# print("DEBUG vis feats", vis_feats.size())
print('Using bayesian ridge regression to evaluate...')
bay_reg = LinearModel.BayesianRegression(X_train, y_train, X_test, y_test,
cross_validation_k)
accuracy, f1_score, bay_reg_y_prediction, bay_reg_cv_score = bay_reg.evaluate(
penalty='l1')
print('Achieved accuracy of %s and f1 score of %s' % (accuracy, f1_score))
print('Using decision tree to evaluate...')
tree = TreeModel.DecisionTree(X_train, y_train, X_test, y_test,
cross_validation_k)
accuracy, f1_score, dec_tree_y_prediction, dec_tree_cv_score = tree.evaluate(
create_image=False)
print('Achieved accuracy of %s and f1 score of %s' % (accuracy, f1_score))
print('Using neural net to evaluate...')
nn = NeuralNet.DeepModel(X_train, y_train, X_validation, y_validation, X_test,
y_test)
accuracy, f1_score, nn_y_predictions = nn.evaluate()
print('Achieved accuracy of %s and f1 score of %s' % (accuracy, f1_score))
print('Using optimized neural net to evaluate...')
opt_nn = NeuralNet.OptimizedDeepModel(db_name=database)
accuracy, f1_score, optimized_nn_y_predictions = opt_nn.evaluate()
print('Achieved accuracy of %s and f1 score of %s' % (accuracy, f1_score))
linewidth = 1
# Create ROC figure
plt.figure(1, dpi=3600, figsize=(8, 5))
fpr, tpr, thresholds = roc_curve(y_test, lin_reg_y_prediction)
plt.plot(fpr, tpr, lw=linewidth, label='linear regression')
def main(read_dir="high.json", write_dir="high.pth"):
base_json_dir = "resource/jsonFile/" + read_dir
base_pth_dir = "resource/pthFile/" + write_dir
with open(base_json_dir, "r", encoding="UTF-8") as file:
intents = json.load(file)
all_words = []
tags = []
xy = []
for intent in intents['intents']:
tag = intent['tag']
tags.append(tag)
for pattern in intent['patterns']:
w = tokenize(pattern)
all_words.extend(w)
xy.append((w, tag))
ignore_word = [",", ".", "'", '"', "?", "!", "^", "@", "#", "_", "-",
"~"] #we need, regular expression
all_words = [stem(w) for w in all_words
if w not in ignore_word] #this is better than using map
all_words = sorted(set(all_words))
tags = sorted(set(tags)) # for order
X_train = []
Y_train = []
for (pattern_sentence, tag) in xy:
bag = bag_of_words(pattern_sentence, all_words)
X_train.append(bag)
label = tags.index(tag)
Y_train.append(label)
X_train = np.array(X_train)
Y_train = np.array(Y_train)
# Hyper-parameters
num_epochs = 1000
batch_size = 8
learning_rate = 0.001
input_size = len(X_train[0])
hidden_size = 8
output_size = len(tags)
class ChatDataset(Dataset):
def __init__(self):
self.n_samples = len(X_train)
self.x_data = X_train
self.y_data = Y_train
# support indexing such that dataset[i] can be used to get i-th sample
def __getitem__(self, index):
return self.x_data[index], self.y_data[index]
# we can call len(dataset) to return the size
def __len__(self):
return self.n_samples
dataset = ChatDataset()
train_loader = DataLoader(dataset=dataset,
batch_size=batch_size,
shuffle=True,
num_workers=0)
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = NeuralNet(input_size, hidden_size, output_size).to(device)
# Loss and optimizer
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)
# Train the model
for epoch in range(num_epochs):
for (words, labels) in train_loader:
words = words.to(device)
labels = labels.to(dtype=torch.long).to(device)
# Forward pass
outputs = model(words)
# if y would be one-hot, we must apply
# labels = torch.max(labels, 1)[1]
loss = criterion(outputs, labels)
# Backward and optimize
optimizer.zero_grad()
loss.backward()
optimizer.step()
if (epoch + 1) % 100 == 0:
print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}')
print(f'final loss: {loss.item():.4f}')
data = {
"model_state": model.state_dict(),
"input_size": input_size,
"hidden_size": hidden_size,
"output_size": output_size,
"all_words": all_words,
"tags": tags
}
torch.save(data, base_pth_dir)
print(f'training complete. write_dir saved to {base_pth_dir}')
attributes = json.load(f)
# Load the creadential saved during training
FILE = "data.pth"
data = torch.load(FILE)
# load all the saved values
inputSize = data["input_size"]
outputSize = data["output_size"]
hiddenSize = data["hidden_size"]
allWords = data["allWords_size"]
tags = data["tags"]
modelState = data["modelState"]
model = NeuralNet(inputSize, hiddenSize, outputSize)
# synthesize next Html tag or attribute provided
def synthesizeTag(sentence, botName, recType):
# load the statedictionary
model.load_state_dict(modelState)
model.eval()
# tokenize find BOG predict the class for new sentence
x = tokenizeAndStemSpoken(sentence, allWords)
# find the predicted output
output = model(x)
_, predicted = torch.max(output, dim=1)
tag = tags[predicted.item()]
def run_simulation(verbose=False,
LRs=[0.025],
save_model=[],
learn=[],
plot=True,
save_experience=[]):
"""
Runs the simulation with the given parameters
"""
EPOCHS = 100
n_plots = 4
n = int(EPOCHS / n_plots)
moves_per_game = 20
for LR in LRs:
avg_rewards_goat = []
avg_rewards_tiger = []
avg_loss_goat = []
avg_loss_tiger = []
if plot and len(learn) != 0:
plt.ion()
iters = []
tiger_plot = PeriodicPlotter('r', x_lim=(0, EPOCHS), y_lim=(0, 10))
goat_plot = PeriodicPlotter('b', x_lim=(0, EPOCHS), y_lim=(0, 10))
# Choosing which model to use
tigerModel = NeuralNet()
# tigerModel = th.load('model-tiger-big.pt')
goatModel = NeuralNet()
# goatModel = th.load('goatModel-learn.pt')
for i in tqdm(range(EPOCHS)):
# Initialize this round of game
brd = Board()
brd.init_game()
# Initialize the agents and set their model
goat_ = GoatAgent(brd, LR=LR)
goat_.set_model(goatModel)
tiger_ = TigerAgent(brd, LR)
tiger_.set_model(tigerModel)
players = [goat_, tiger_]
if verbose:
if i != 0:
sys.stdout.write("\033[6F")
print(brd)
over = False # Whether the current game is over or not
for _ in range(moves_per_game):
for player in players:
try:
player.make_move()
# print('player', player)
if verbose:
sys.stdout.write("\033[6F")
print(brd)
time.sleep(0.5)
except Exception as e: # When the player doesn't have a move
over = True
break
if over:
break
# Save the experience from this iteration
if Goat in save_experience:
goat_.save_experience('experience-goat-dqn-test.txt')
if Tiger in save_experience:
tiger_.save_experience('experience-tiger-dqn-test.txt')
# Aggregate the total reward in this round
# avg_rewards_goat.append(goat_reward/len(goat_.data))
# Learn from this experience
if plot and i % n == 0:
iters.append(i)
if Goat in learn:
goat_.prepare_data()
goat_.learn()
goat_reward = 0
for exp in goat_.data:
goat_reward += exp[-1]
if plot and i % n == 0:
loss_goat = goat_.test('experience-goat-dqn-test.txt')
avg_loss_goat.append(loss_goat)
goat_plot.plot(iters, avg_loss_goat)
if Tiger in learn:
tiger_.prepare_data()
tiger_.learn()
tiger_reward = 0
for exp in tiger_.data:
tiger_reward += exp[-1]
if plot and i % n == 0:
loss_tiger = tiger_.test('experience-tiger-test.txt')
avg_rewards_tiger.append(tiger_reward / len(tiger_.data))
avg_loss_tiger.append(loss_tiger)
tiger_plot.plot(iters, avg_loss_tiger)
if plot:
# plt.legend(['LR: %f'% LR for LR in LRs])
plt.show()
plt.savefig('result1.png')
# Save the currently trained model
if Goat in save_model:
th.save(goatModel, 'model-goat-dqn.pt')
if Tiger in save_model:
th.save(tigerModel, 'model-tiger-dqn.pt')
"""
Here we are predicting output for fizzbuzz game
with our neural network
"""
import numpy as np
from model import NeuralNet
from generate_data import inputs, labels
# Min is 1 and max is 1024
first = 101
last = 1024
X = inputs(first, last)
y = labels(first, last)
model = NeuralNet(input_shape=(10, ))
model.compile(lr=0.001)
model.train(X, y, batch_size=32, epochs=1000)
first_test = 1
last_test = 100
X_test = inputs(first_test, last_test)
y_pred = model.predict(X_test)
iter = range(first_test, last_test + 1)
for i in range(last_test - first_test + 1):
if y_pred[i] == 0:
pred = i + 1
elif y_pred[i] == 1:
pred = "fizz"
elif y_pred[i] == 2:
pred = "buzz"
else:
output_size = len(tags)
input_size = len(X_train[0])
learning_rate = 0.00025
num_epochs = 1000
dataset = ChatDataset()
train_loader = DataLoader(dataset=dataset,
batch_size=batch_size,
shuffle=True,
num_workers=2)
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
print("Using device: ", device)
model = NeuralNet(input_size, hidden_size, output_size).to(device)
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(),
learning_rate,
weight_decay=.005)
print("Starting training")
for epoch in range(num_epochs):
for (words, labels) in train_loader:
words = words.to(device)
labels = labels.to(dtype=torch.long).to(device)
outputs = model(words)
loss = criterion(outputs, labels)
batchSize = 8
learningRate = 0.001
numberOfEpochs = 2000
inputSize = len(XTrain[0])
hiddenSize = 8
outputSize = len(tags)
dataset = ChatDataset()
trainLoader = DataLoader(dataset=dataset,
batch_size=batchSize,
shuffle=True,
num_workers=0)
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = NeuralNet(inputSize, hiddenSize, outputSize).to(device)
# loss and optimizer
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=learningRate)
for epoch in range(numberOfEpochs):
for (words, labels) in trainLoader:
words = words.to(device)
labels = labels.to(device)
lables = labels.to(dtype=torch.long)
# forward
outputs = model(words)
loss = criterion(outputs, labels)
value = np.random.randint(2, size=(N, ))
value = value.astype('float32')
end = np.random.randint(2, size=(N, 19, 19, 2))
end = end.astype('float32')
golois.getBatch(input_data, policy, value, end)
else:
input_data = np.load('./input_data.npy')
policy = np.load('./policy.npy')
value = np.load('./value.npy')
end = np.load('./end.npy')
GoNeuralNet = NeuralNet(config.REG_CONST, config.LEARNING_RATE,
(19, 19, planes), moves, config.HIDDEN_CNN_LAYERS,
config.MOMENTUM)
GoNeuralNet.summary()
GoNeuralNet.fit(input_data, {
'policy': policy,
'value': value
},
epochs=config.EPOCHS,
verbose=1,
validation_split=0.1,
batch_size=config.BATCH_SIZE)
GoNeuralNet.save_model(0.1)
### SET-UP DATASET ###
train_files = list(
pathlib.Path(f'{args.samples_path}/train').glob('sample_*.pkl'))
valid_files = list(
pathlib.Path(f'{args.samples_path}/valid').glob('sample_*.pkl'))
log(f"{len(train_files)} training samples", logfile)
log(f"{len(valid_files)} validation samples", logfile)
train_files = [str(x) for x in train_files]
valid_files = [str(x) for x in valid_files]
valid_data = LazyDataset(valid_files)
valid_data = DataLoader(valid_data, batch_size=valid_batch_size)
model = NeuralNet(device).to(device)
# Loss and optimizer
criterion = nn.CrossEntropyLoss().to(device)
if args.optimizer == 'Adam':
optimizer = torch.optim.Adam(model.parameters(), lr=lr)
elif args.optimizer == 'RMSprop':
optimizer = torch.optim.RMSprop(model.parameters(), lr=lr)
else:
raise Exception('Invalid optimizer')
# Should set lr *= 0.2 when .step() is called
lr_scheduler = ExponentialLR(optimizer, 0.2)
### TRAINING LOOP ###
best_loss = np.inf
plateau_count = 0
import cv2
import numpy as np
from model import NeuralNet
net = NeuralNet()
# creating a 600 x 600 pixels canvas for mouse drawing
canvas = np.ones((600, 600), dtype="uint8") * 255
# designating a 400 x 400 pixels point of interest on which digits will be drawn
canvas[100:500, 100:500] = 0
start_point = None
end_point = None
is_drawing = False
def draw_line(img, start_at, end_at):
cv2.line(img, start_at, end_at, 255, 15)
def on_mouse_events(event, x, y, flags, params):
global start_point
global end_point
global canvas
global is_drawing
if event == cv2.EVENT_LBUTTONDOWN:
is_drawing = True
if is_drawing:
start_point = (x, y)
elif event == cv2.EVENT_MOUSEMOVE:
if is_drawing:
with open(result_file, 'w', newline='') as csvfile:
writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
writer.writeheader()
policy_type = 'gcnn'
policy_name = 'baseline'
print(f"{policy_type}:{policy_name}...")
for seed in seeds:
rng = np.random.RandomState(seed)
torch.manual_seed(rng.randint(np.iinfo(int).max))
policy = {}
policy['name'] = policy_name
policy['type'] = policy_type
policy['model'] = NeuralNet(device).to(device)
policy['model'].load_state_dict(torch.load(f"trained_models/{args.problem}/baseline/{seed}/{args.lr}/{args.optimizer}/best_params.pkl"))
test_data = LazyDataset(test_files)
test_data = DataLoader(test_data, batch_size=test_batch_size)
policy['model'].eval()
with torch.no_grad():
test_kacc = process(policy, test_data, top_k)
print(f" {seed} " + " ".join([f"acc@{k}: {100*acc:4.1f}" for k, acc in zip(top_k, test_kacc)]))
writer.writerow({
**{
'policy': f"{policy['type']}:{policy['name']}",
'seed': seed,
},
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
with open('intents.json', 'r') as f:
intents = json.load(f)
FILE = "data.pth"
data = torch.load(FILE)
input_size = data["input_size"]
hidden_size = data["hidden_size"]
output_size = data["output_size"]
all_words = data["all_words"]
tags = data["tags"]
model_state = data["model_state"]
model = NeuralNet(input_size=input_size, hidden_size=hidden_size, num_classes=output_size).to(device)
model.load_state_dict(model_state)
model.eval()
bot_name = "Venancio"
print("Chatiamos! escribe 'salir' para salir")
while True:
sentence = input('Tu: ')
if sentence == "salir":
break
sentence = tokenize(sentence)
X = bag_of_words(sentence, all_words)
X = X.reshape(1, X.shape[0])
X = torch.from_numpy(X)
X_train = np.array(X_train)
y_train = np.array(y_train)
# Hyperparameters
batch_size = 8
hidden_size = 8
output_size = len(tags)
input_size = len(X_train[0]) #len(all_words)
learning_rate = 0.001
num_epochs = 1000
dataset = ChatDataset(X_train, y_train)
train_loader = DataLoader(dataset=dataset, batch_size=batch_size, shuffle=True, num_workers=0)
device = torch_device('cuda' if torch_cuda.is_available() else 'cpu')
model = NeuralNet(input_size, hidden_size, output_size).to(device)
# Loss and optimizer
criterion = nn.CrossEntropyLoss()
optimizer = Adam(model.parameters(), lr=learning_rate)
# Our training loop
for epoch in range(num_epochs):
for (words, labels) in train_loader:
words = words.to(device)
labels = labels.to(device)
# Forward
outputs = model(words)
loss = criterion(outputs, labels.long())
model_state = torch.load(FILE)
chat_data = pd.read_csv("database.csv")
response_data = {
tag.strip(): sentence
for tag, sentence in zip(chat_data["tag"].values,
chat_data["sentence"].values)
}
input_size = model_state["input_size"]
hidden_size = model_state["hidden_size"]
output_size = model_state["output_size"]
all_words = model_state["all_words"]
tags = model_state["tags"]
model_state = model_state["model_state"]
model = NeuralNet(input_size, hidden_size, output_size)
model.load_state_dict(model_state)
while True:
sentence = input("Humano:")
X = bag_of_words(tokenize(sentence), all_words)
X = X.reshape(1, X.shape[0])
X = torch.from_numpy(X)
output = model(X)
# Se obtiene el valor maximo de salida
value, predicted = torch.max(output, dim=1)
# Se calcula cual eficaz es el maximo valor
probs = torch.softmax(output, dim=1)
for e, b in zip(en, body):
print(d)
print([id2word_snli[word_id] for word_id in head])
print([id2word_snli[word_id] for word_id in b])
print(e)
'''
# embedding = preprocess.embedding
vocab_size = len(preprocess.word2id)
print("vocab_size:{0}".format(vocab_size))
device = torch.device(
'cuda:{0}'.format(gpu) if torch.cuda.is_available() else 'cpu')
# device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
if argvs[1] == 'NN':
model = NeuralNet(input_size, hidden_size, num_layers, num_classes,
vocab_size, emb_size, dropout_rate, cosine_similarity,
device).to(device)
if argvs[1] == 'LSTM':
model = LSTM(input_size, hidden_size, num_layers, num_classes, vocab_size,
emb_size, embedding, dropout_rate, cosine_similarity,
device).to(device)
if argvs[1] == 'CE':
model = CE(input_size, hidden_size, num_layers, num_classes, vocab_size,
emb_size, embedding, dropout_rate, cosine_similarity,
device).to(device)
if argvs[1] == 'ACE':
model = ACE(input_size, hidden_size, num_layers, num_classes, vocab_size,
emb_size, embedding, dropout_rate, cosine_similarity,
device).to(device)
if argvs[1] == 'WACE':
model = WACE(input_size, hidden_size, num_layers, num_classes, vocab_size,
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
with open('intents.json', 'r') as json_data:
intents = json.load(json_data)
FILE = "data.pth"
data = torch.load(FILE)
input_size = data["input_size"]
hidden_size = data["hidden_size"]
output_size = data["output_size"]
all_words = data['all_words']
tags = data['tags']
model_state = data["model_state"]
model = NeuralNet(input_size, hidden_size, output_size).to(device)
model.load_state_dict(model_state)
model.eval()
bot_name = "Mahasiswa Unpam"
print("Mulai Chat! (type 'quit' to exit)")
while True:
# sentence = "do you use credit cards?"
sentence = input("Kamu: ")
if sentence == "quit":
break
sentence = tokenize(sentence)
X = bag_of_words(sentence, all_words)
X = X.reshape(1, X.shape[0])
X = torch.from_numpy(X).to(device)
# %%
# Looking at one element of the dataset
example = iter(train_loader)
samples, labels = example.next()
print(samples.shape, labels.shape)
for i in range(9):
plt.subplot(3, 3, i + 1)
plt.imshow(samples[i][0], cmap='gray')
plt.show()
# %%
# Traning the model
model = NeuralNet(input_size=input_size,
hidden_size=hidden_size,
output_size=num_classes,
lr=lr).to(device)
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr)
for epoch in range(num_epochs):
for i, (samples, labels) in enumerate(train_loader):
# Reshaping the images
samples = samples.reshape(-1, input_size).to(device)
labels = labels.to(device)
predictions = model(samples)
loss = criterion(predictions, labels)
def __len__(self):
return self.n_samples
batch_size = 8
hidden_size = 8
output_size = len(tags)
input_size = len(X_train[0])
learning_rate = 0.001
num_epochs = 100
dataset = ChatDataset()
train_loader = DataLoader(dataset = dataset, batch_size = batch_size, shuffle = True, num_workers = 0)
device = 'cpu'
model = NeuralNet(input_size, hidden_size, output_size).to(device)
criterion = nn.CrossEntropyLoss()
optimizer= torch.optim.Adam(model.parameters(), lr = learning_rate)
for epoch in range(num_epochs):
for (words, labels) in train_loader:
words = words.to(device)
labels = labels.to(device)
outputs = model(words)
loss = criterion(outputs,labels)
optimizer.zero_grad()
loss.backward()
optimizer.step()
if __name__ == "__main__":
data = []
labels = []
print("Loading Data")
imagePaths = sorted(list(paths.list_images("dataset")))
random.seed(42)
random.shuffle(imagePaths)
# loop over the input images
for imagePath in imagePaths:
image = cv2.imread(imagePath)
image = cv2.resize(image, (IMAGE_DIMS[0], IMAGE_DIMS[1]))
image = img_to_array(image)
data.append(image)
# update labels list
label = imagePath.split(os.path.sep)[-2]
labels.append(label)
data = np.array(data, dtype="float") / 255.0
labels = np.array(labels)
for i in range(len(labels)):
labels[i] = nameToNum[labels[i]]
labels = to_categorical(labels, num_classes=2)
model = NeuralNet(data, labels)
def train(cpu, args):
rank = args.nr * args.cpus + cpu
dist.init_process_group(
backend="gloo",
init_method="file:///Users/thanhsom/Downloads/computer_network_extra/model/setup.txt",
world_size=args.world_size,
rank=rank
)
torch.manual_seed(0)
# Hyperparameters:
batch_size = 100 # NOTE: If ran out of memory, try changing this value to 64 or 32
learning_rate = 0.0001
# Create model:
model = NeuralNet()
# Define loss function and optimizer:
loss_fn = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), learning_rate)
# Wrap the model for ddp:
model = nn.parallel.DistributedDataParallel(model, device_ids=None)
# Data loading:
train_dataset = torchvision.datasets.MNIST(
root='./data',
train=True,
transform=transforms.ToTensor(),
download=True,
)
train_size = int(args.scale * len(train_dataset))
test_size = len(train_dataset) - train_size
train_dataset = torch.utils.data.random_split(train_dataset, [train_size, test_size])[0]
# Sampling the dataset to avoid same inputs order:
train_sampler = torch.utils.data.distributed.DistributedSampler(
train_dataset,
num_replicas=args.world_size,
rank=rank
)
train_loader = torch.utils.data.DataLoader(
dataset=train_dataset,
shuffle=False,
num_workers=0,
pin_memory=True,
sampler=train_sampler
)
start = datetime.now()
total_step = len(train_loader)
lossVal = []
scale = 10
print(args.epochs)
for epoch in range(args.epochs):
for i, (images, labels) in enumerate(train_loader):
# Forward pass:
outputs = model(images)
loss = loss_fn(outputs, labels)
# Backward pass:
optimizer.zero_grad()
loss.backward()
optimizer.step()
# For logging:
if (i + 1) % batch_size and cpu == 0:
print('Epoch [{}/{}], Step [{}/{}], Loss: {:.4f}'.format
(epoch + 1, args.epochs, i + 1, total_step, loss.item()))
if cpu == 0:
print("Training completed in: " + str(datetime.now() - start))
PATH = "trained/"+args.type+"/"+args.address+".pt"
torch.save(model, PATH)
def main():
bet_tracker = BetTracker()
match_data = read_match_data(season='2017-2018')
player_data = read_player_data(season='2017-2018')
net = NeuralNet()
bank = [100]
all_odds = []
for match in match_data:
print(match['info']['date'], match['info']['home team'],
match['info']['away team'])
home_players_matched = match_lineups_to_fifa_players(
match['info']['home lineup names'],
match['info']['home lineup numbers'],
match['info']['home lineup nationalities'],
constants.LINEUP_TO_PLAYER_TEAM_MAPPINGS['ALL']
[match['info']['home team']], match['info']['season'], player_data)
away_players_matched = match_lineups_to_fifa_players(
match['info']['away lineup names'],
match['info']['away lineup numbers'],
match['info']['away lineup nationalities'],
constants.LINEUP_TO_PLAYER_TEAM_MAPPINGS['ALL']
[match['info']['away team']], match['info']['season'], player_data)
home_feature_vector = create_feature_vector_from_players(
home_players_matched)
away_feature_vector = create_feature_vector_from_players(
away_players_matched)
feature_vector = np.array(home_feature_vector +
away_feature_vector).reshape(-1, 36)
feature_vector = normalise_features(feature_vector)
probabilities = net.predict(feature_vector)
pred_home_odds, pred_draw_odds, pred_away_odds = [
1 / x for x in probabilities[0]
]
home_odds, draw_odds, away_odds = match['info']['home odds'], match[
'info']['draw odds'], match['info']['away odds']
all_odds.append((pred_home_odds, home_odds))
all_odds.append((pred_away_odds, away_odds))
if pred_home_odds < home_odds < 3.2 and 0.02 <= probabilities[0][
0] - 1 / home_odds:
stake = calculate_stake(home_odds,
probability=1 / pred_home_odds,
method='kelly') * bet_tracker.bankroll
profit = stake * home_odds - stake
bet = Bet(true_odds=home_odds,
predicted_odds=pred_home_odds,
stake=stake,
profit=profit,
match=match,
type='home')
bet_tracker.make_bet(bet)
if match['info']['home goals'] > match['info']['away goals']:
bet_tracker.bet_won()
else:
bet_tracker.bet_lost()
bank.append(bet_tracker.bankroll)
elif pred_away_odds < away_odds < 3.2 and 0.02 <= probabilities[0][
2] - 1 / away_odds:
stake = calculate_stake(away_odds,
probability=1 / pred_away_odds,
method='kelly') * bet_tracker.bankroll
profit = stake * away_odds - stake
bet = Bet(true_odds=away_odds,
predicted_odds=pred_away_odds,
stake=stake,
profit=profit,
match=match,
type='away')
bet_tracker.make_bet(bet)
if match['info']['home goals'] < match['info']['away goals']:
bet_tracker.bet_won()
else:
bet_tracker.bet_lost()
bank.append(bet_tracker.bankroll)
return bet_tracker, bank, all_odds
args = parser.parse_args()
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
# set the seed for generating random numbers
torch.manual_seed(args.seed)
if torch.cuda.is_available():
torch.cuda.manual_seed(args.seed)
# get train loader
train_loader = _get_train_loader(args.batch_size,
args.data_dir) # data_dir from above..
## TODO: Build the model by passing in the input params
# To get params from the parser, call args.argument_name, ex. args.epochs or ards.hidden_dim
# Don't forget to move your model .to(device) to move to GPU , if appropriate
model = NeuralNet(args.input_dim, args.hidden_dim,
args.output_dim).to(device)
# Given: save the parameters used to construct the model
save_model_params(model, args.model_dir)
## TODO: Define an optimizer and loss function for training
optimizer = optim.Adam(model.parameters(), lr=args.lr)
criterion = nn.MSELoss()
# Trains the model (given line of code, which calls the above training function)
# This function *also* saves the model state dictionary
train(model, train_loader, args.epochs, optimizer, criterion, device)
def train(args, labeled, resume_from, ckpt_file):
print("========== In the train step ==========")
batch_size = args["batch_size"]
lr = args["learning_rate"]
momentum = args["momentum"]
epochs = args["train_epochs"]
train_split = args["split_train"]
CSV_FILE = "./data/mushrooms.csv"
dataset = MushroomDataset(CSV_FILE)
train_dataset = torch.utils.data.Subset(
dataset, list(range(int(train_split * len(dataset))))
)
train_subset = Subset(train_dataset, labeled)
train_loader = DataLoader(train_subset, batch_size=batch_size, shuffle=True)
net = NeuralNet()
net = net.to(device=device)
criterion = torch.nn.BCELoss()
optimizer = optim.SGD(net.parameters(), lr=float(lr), momentum=momentum)
if resume_from is not None:
ckpt = torch.load(os.path.join(args["EXPT_DIR"], resume_from + ".pth"))
net.load_state_dict(ckpt["model"])
optimizer.load_state_dict(ckpt["optimizer"])
else:
getdatasetstate(args)
net.train()
for epoch in tqdm(range(args["train_epochs"]), desc="Training"):
running_loss = 0
for i, batch in enumerate(train_loader, start=0):
data, labels = batch
data = data.to(device)
labels = labels.to(device)
optimizer.zero_grad()
output = net(data)
loss = criterion(output, labels)
loss.backward()
optimizer.step()
running_loss += loss.item()
if i % 1000:
print(
"epoch: {} batch: {} running-loss: {}".format(
epoch + 1, i + 1, running_loss / 1000
),
end="\r",
)
running_loss = 0
print("Finished Training. Saving the model as {}".format(ckpt_file))
ckpt = {"model": net.state_dict(), "optimizer": optimizer.state_dict()}
torch.save(ckpt, os.path.join(args["EXPT_DIR"], ckpt_file + ".pth"))
return
