def readCommand(argv):
"Processes the command used to run from the command line."
from optparse import OptionParser
parser = OptionParser(USAGE_STRING)
parser.add_option(
'-i',
'--input_bin',
help=default('The type of classifier'),
default='CS_763_Deep_Learning_HW/input_criterion_sample_1.bin')
parser.add_option('-t',
'--target_bin',
help=default('The size of the training set'),
default='CS_763_Deep_Learning_HW/target_sample_1.bin',
type="string")
parser.add_option(
'-g',
'--ig',
help=default('Whether to use enhanced features'),
default='CS_763_Deep_Learning_HW/gradCriterionInput_sample_1.bin',
type="string")
# parser.add_option('-a', '--autotune', help=default("Whether to automatically tune hyperparameters"), default=False, action="store_true")
# parser.add_option('-i', '--iterations', help=default("Maximum iterations to run training"), default=3, type="int")
# parser.add_option('-s', '--test', help=default("Amount of test data to use"), default=TEST_SET_SIZE, type="int")
# parser.add_option('-v', '--validate', help=default("Whether to validate when training (for graphs)"), default=False, action="store_true")
# parser.add_option('-d', '--dataset', help=default("Specifies the data set to use"), choices=['d1', 'd2'], default='d1')
# parser.add_option('-k', '--classes', help=default("Specifies the number of classes"), default=10, type="int")
options, otherjunk = parser.parse_args(argv)
if len(otherjunk) != 0:
raise Exception('Command line input not understood: ' + str(otherjunk))
args = {}
input_bin_path = options.input_bin
target_bin_path = options.target_bin
grad_input_bin_path = options.ig
input_bin = torch.tensor(torchfile.load(input_bin_path)).double()
target_bin = torch.tensor(torchfile.load(target_bin_path)).double()
grad_input_bin = torch.tensor(torchfile.load(grad_input_bin_path)).double()
size = target_bin.shape[0]
# print size
for j in range(size):
target_bin[j] -= 1
# print target_bin
# grad_Input_bin = options.grad_Input_bin
# print grad_input_bin
# loss = Criterion.forward(input_bin, target_bin)
# gradLoss = Criterion.backward(input_bin, target_bin)
criterion = Criterion.Criterion()
loss = criterion.forward(input_bin, target_bin)
print "Loss is -----", loss
# print loss
# print input_bin.shape
# print gradLoss
gradInput = criterion.backward(input_bin, target_bin)
def checkNewParetsName(item, array):
a = {}
for sth, crit in array.items():
if crit.name == item.name:
for i in xrange(times):
new_name = getNewCriterionName(crit.name, crit.parent[i])
a[new_name] = Criterion(new_name)
a[new_name].setParent(crit.parent[i])
else:
a[sth] = array[sth]
return a
def get_hierarchy(hierarchy, par='-', a={}, level=0):
if hierarchy != None:
rootNodes = hierarchy.findall("node")
for node in rootNodes:
parent = node.find("criterionID").text
if not a.has_key(parent):
a[parent] = Criterion(parent)
a[parent].setParent(par)
a[parent].level = level
else:
a[parent].setParent(par)
get_hierarchy(node, parent, a, level + 1)
return a
def divideCriteria(item, array):
a = {}
for sth, crit in array.items():
if sth == item:
i = 0
for parent in crit.parent:
i += 1
new_name = getNewCriterionName(item, parent)
a[new_name] = Criterion(new_name)
a[new_name].setParent(parent)
else:
a[sth] = array[sth]
return a
def buildNewHierarchy(a, root, hierarchyArray, newParentName=None):
if newParentName == None:
newParentName = root
for criterion in hierarchyArray.values():
if criterion.hasParent(root):
if criterion.parentsNumber() > 1:
for i in xrange(criterion.parentsNumber()):
newName = getNewCriterionName(criterion.name,
newParentName)
a[newName] = Criterion(newName)
a[newName].level = hierarchyArray[criterion.name].level
a[newName].setParent(newParentName)
buildNewHierarchy(a, criterion.name, hierarchyArray,
newName)
else:
a[criterion.name] = hierarchyArray[criterion.name]
buildNewHierarchy(a, criterion.name, hierarchyArray)
return a
def train_and_test(my_model, trainingData, trainingLabels, noIters, batchSize,
alpha, lr): # can add lambda
# best_accuracy = 0
# best_epoch = 0
noBatches = int(trainingLabels.shape[0] / batchSize)
my_criterion = Criterion.Criterion()
# loss = np.zeros(noBatches)
# accuracy = np.zeros(noBatches)
for iter in range(noIters):
for batch in range(noBatches):
trData = trainingData[batch * batchSize:(batch + 1) * batchSize, :]
trLabels = trainingLabels[batch * batchSize:(batch + 1) *
batchSize]
trOutputs = my_model.forward(trData, True)
# loss_tr = my_criterion.forward(trOutputs, trLabels).item()
dl_do = my_criterion.backward(trOutputs, trLabels)
my_model.backward(trData, dl_do, alpha, lr)
trOutputs = trOutputs.argmax(1)
import torch
from Model import *
from readData4 import *
import numpy as np
from Criterion import *
import sys
torch.set_printoptions(precision=3)
torch.set_default_tensor_type('torch.DoubleTensor')
model = Model(-1,128,153,153,1)
lossClass = Criterion()
def printAcc(start,batch_size):
print("\nPrinting Accuracy Now~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n")
count = 0
for i in range(batch_size):
trial_data = data[start+i].view(1,-1)
yPred = model.forward(trial_data)
count += (int(yPred.view(1,-1).max(dim=1)[1])==int(labels[start+i]))
#print(int(yPred.view(1,-1).max(dim=1)[1]),int(labels[i]),yPred.tolist())
print(count/batch_size)
print("\nAccuracy block over~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\n")
def submitPred(str):
total_test = 395
temp_stdout = sys.stdout
sys.stdout = open(str, "w")
import torch
import loadModel
from dataset import Data
import Criterion
classifier = loadModel.load()
# device = 'cpu'
device = 'cuda:0'
trainData = Data(test=False)
criterion = Criterion.Criterion()
batch_size = 32
epochs = 200
alpha = 1e-2
momentum = 0.9
for epoch in range(epochs):
if epoch == 60:
alpha = 5e-3
elif epoch == 100:
alpha = 1e-3
correct = 0
count = 0
for i in range(0, trainData.m, batch_size):
# print i
X, y = trainData.sample(batch_size, i)
classifier.clearGradParam()
y_pred = classifier.forward(X)
# print y_pred
def readCommand(argv):
"Processes the command used to run from the command line."
from optparse import OptionParser
parser = OptionParser(USAGE_STRING)
parser.add_option('-c',
'--config',
help=default('modelConfig'),
default='CS 763 Deep Learning HW/modelConfig_1.txt')
parser.add_option('-i',
'--i',
help=default('input'),
default='CS 763 Deep Learning HW/input_sample_1.bin',
type="string")
parser.add_option(
'-g',
'--og',
help=default('gradoutput'),
default='CS 763 Deep Learning HW/gradOutput_sample_1.bin',
type="string")
parser.add_option('-o', '--o', help=default('output'), type="string")
parser.add_option('-w', '--ow', help=default('gradweights'), type="string")
parser.add_option('-b', '--ob', help=default('gradb'), type="string")
parser.add_option('-d', '--ig', help=default('gradinput'), type="string")
options, otherjunk = parser.parse_args(argv)
if len(otherjunk) != 0:
raise Exception('Command line input not understood: ' + str(otherjunk))
args = {}
model_config_path = options.config
input_path = options.i
gradoutput_path = options.og
output_path = options.o
gradweights_path = options.ow
gradb_path = options.ob
gradinput_path = options.ig
modelConfig_file = open(model_config_path, "r")
data = modelConfig_file.readlines()
my_model = Model.Model()
my_criterion = Criterion.Criterion()
input_weight = 0
Bias_weight = 0
Number_layer = int(data[0])
for i in range(Number_layer):
layer = data[1 + i].split()
if (len(layer) > 1):
my_model.addLayer(Linear(int(layer[1]), int(layer[2])))
else:
my_model.addLayer(ReLu())
Path_sample_weight = data[Number_layer + 1][:-1]
Path_sample_bias = data[Number_layer + 2][:-1]
input = torchfile.load(input_path)
input = torch.tensor(input).double().reshape((input.shape[0], -1))
input_weight = torchfile.load(Path_sample_weight)
input_bias = torchfile.load(Path_sample_bias)
input_weight = [torch.tensor(weight).double() for weight in input_weight]
input_bias = [
torch.tensor(bias).double().reshape((-1, 1)) for bias in input_bias
]
Outputs = my_model.forward2(input, input_weight, input_bias, True)
dl_do = my_criterion.backward(Outputs, trLabels)
# gradoutput = my_model.backward(input, dl_do, 0, 0)
[gradInput, gradWeights, gradBias] = my_model.backward2(input, dl_do, 0, 0)
torch.save(Outputs, output_path)
torch.save(gradWeights, gradweights_path)
torch.save(gradBias, gradb_path)
torch.save(gradInput, gradinput_path)
