def model_fn(model_dir):
"""Load the PyTorch model from the `model_dir` directory."""
print("Loading model.")
# First, load the parameters used to create the model.
model_info = {}
model_info_path = os.path.join(model_dir, 'model_info.pth')
with open(model_info_path, 'rb') as f:
model_info = torch.load(f)
print("model_info: {}".format(model_info))
# Determine the device and construct the model.
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = NeuralNet(model_info['input_dim'], model_info['hidden_dim'], model_info['output_dim'])
# Load the stored model parameters.
model_path = os.path.join(model_dir, 'model.pth')
with open(model_path, 'rb') as f:
model.load_state_dict(torch.load(f))
# prep for testing
model.to(device).eval()
print("Done loading model.")
return model
def get_prediction(text, embedding_matrix):
model = NeuralNet(embedding_matrix)
model.to(torch.device("cpu"))
model.load_state_dict(torch.load('./pytorch_model/best_model.pt'))
model.eval()
with torch.no_grad():
pred = model(text)
pred_logit = sigmoid(pred.detach().cpu().numpy())[0][0]
pred_label = np.where(pred_logit >= 0.5, 1, 0)
answer = '긍정' if pred_label == 1 else '부정'
return answer
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"]
loader = processData(args, stageFor="train", indices=labeled)
net = NeuralNet()
net = net.to(device=device)
criterion = torch.nn.CrossEntropyLoss()
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(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
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"]
loader = processData(args, stageFor="test")
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 = args["test_size"]
with tqdm(total=n_val, desc="Testing round", unit="batch", leave=False) as pbar:
for step, (batch_x, batch_y) in enumerate(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()
class_probabilities = logit.cpu().numpy().tolist()
index_max = np.argmax(class_probabilities)
predictions[predix] = index_max
predix += 1
pbar.update()
# unpack predictions
predictions = [val for key, val in predictions.items()]
truelabels = [val for key, val in truelabels.items()]
return {"predictions": predictions, "labels": truelabels}
def infer(args, unlabeled, ckpt_file):
print("========== In the inference step ==========")
batch_size = args["batch_size"]
lr = args["learning_rate"]
momentum = args["momentum"]
epochs = args["train_epochs"]
train_split = args["split_train"]
loader = processData(args, stageFor="infer", indices=unlabeled)
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()
n_val = len(unlabeled)
predictions = {}
predix = 0
with tqdm(total=n_val, desc="Inference round", unit="batch", leave=False) as pbar:
for step, (batch_x, batch_y) in enumerate(loader):
with torch.no_grad():
batch_x = batch_x.to(device)
batch_y = batch_y.to(device)
prediction = net(batch_x)
for logit in prediction:
predictions[unlabeled[predix]] = {}
class_probabilities = logit.cpu().numpy().tolist()
predictions[unlabeled[predix]]["pre_softmax"] = class_probabilities
index_max = np.argmax(class_probabilities)
predictions[unlabeled[predix]]["prediction"] = index_max
predix += 1
pbar.update()
return {"outputs": predictions}
mkdir(output_path)
# models
encoder = NeuralNet(config.getint("dataset", "patch_size") *
config.getint("dataset", "patch_size") * 3,
100,
10,
activation=nn.Tanh)
# load the state
state_path = config.get("testing", "state_path")
encoder.load_state_dict(torch.load(state_path))
# move to gpu if needed
if use_gpu:
encoder = encoder.to(torch.device("cuda:0"))
data_path = config.get("testing", "data_path")
temp_path = config.get("testing", "temp_path")
for fn in os.listdir(temp_path):
print("processing template image")
path = os.path.join(temp_path, fn)
# image_output_path = os.path.join(output_path, fn.split(".")[0])
# mkdir(image_output_path)
# dataset
dataset = Patchifier(path,
int(config.get("dataset", "patch_size")),
whiten=config.getboolean("dataset", "whiten"),
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 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
def infer(args, unlabeled, ckpt_file):
print("========== In the inference 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, unlabeled)
train_loader = DataLoader(train_subset, 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()
n_val = len(unlabeled)
predictions = {}
predix = 0
with tqdm(total=n_val, desc="Inference round", unit="batch", leave=False) as pbar:
for step, (batch_x, batch_y) in enumerate(train_loader):
with torch.no_grad():
batch_x = batch_x.to(device)
batch_y = batch_y.to(device)
prediction = net(batch_x)
for logit in prediction:
predictions[unlabeled[predix]] = {}
prediction = 0
# since I include sigmoid as the last layer's activation function, logit = %
if logit.cpu().numpy() > 0.5:
prediction = 1
predictions[unlabeled[predix]]["prediction"] = prediction
predictions[unlabeled[predix]]["pre_softmax"] = [
[
logit_fn(logit.cpu().numpy()[0]),
logit_fn(1 - logit.cpu().numpy()[0]),
]
]
predix += 1
pbar.update()
# print("predictions",predictions)
return {"outputs": predictions}
