def main():
# Fixing seeds for reproducibility
tf.set_random_seed(42)
np.random.seed(42)
# Hyper Param pre-processing
args = helpermethods.getArgs()
sigma = args.sigma
depth = args.depth
regT = args.rT
regW = args.rW
regV = args.rV
totalEpochs = args.epochs
learningRate = args.learning_rate
dataDir = args.data_dir
outFile = args.output_file
(dataDimension, numClasses,
Xtrain, Ytrain, Xtest, Ytest) = helpermethods.preProcessData(dataDir)
sparW = args.sW
sparV = args.sV
sparT = args.sT
if args.batch_size is None:
batchSize = np.maximum(100, int(np.ceil(np.sqrt(Ytrain.shape[0]))))
else:
batchSize = args.batch_size
useMCHLoss = True
if numClasses == 2:
numClasses = 1
X = tf.placeholder("float32", [None, dataDimension])
Y = tf.placeholder("float32", [None, numClasses])
currDir = helpermethods.createTimeStampDir(dataDir)
helpermethods.dumpCommand(sys.argv, currDir)
# numClasses = 1 for binary case
bonsaiObj = Bonsai(numClasses, dataDimension, depth, sigma)
bonsaiTrainer = BonsaiTrainer(bonsaiObj,
regW, regT, regV,
sparW, sparT, sparV,
learningRate, X, Y, useMCHLoss, outFile)
sess = tf.InteractiveSession()
sess.run(tf.global_variables_initializer())
bonsaiTrainer.train(batchSize, totalEpochs, sess,
Xtrain, Xtest, Ytrain, Ytest, dataDir, currDir)
def main():
# change cuda:0 to cuda:gpuid for specific allocation
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
# Fixing seeds for reproducibility
torch.manual_seed(42)
np.random.seed(42)
# Hyper Param pre-processing
args = helpermethods.getArgs()
dataDir = args.data_dir
cell = args.cell
inputDims = args.input_dim
batch_first = args.batch_first
hiddenDims = args.hidden_dim
totalEpochs = args.epochs
learningRate = args.learning_rate
outFile = args.output_file
batchSize = args.batch_size
decayStep = args.decay_step
decayRate = args.decay_rate
wRank = args.wRank
uRank = args.uRank
sW = args.sW
sU = args.sU
update_non_linearity = args.update_nl
gate_non_linearity = args.gate_nl
(dataDimension, numClasses, Xtrain, Ytrain, Xtest, Ytest,
mean, std) = helpermethods.preProcessData(dataDir)
assert dataDimension % inputDims == 0, "Infeasible per step input, " + \
"Timesteps have to be integer"
currDir = helpermethods.createTimeStampDir(dataDir, cell)
helpermethods.dumpCommand(sys.argv, currDir)
helpermethods.saveMeanStd(mean, std, currDir)
if cell == "FastGRNN":
FastCell = FastGRNNCell(inputDims, hiddenDims,
gate_nonlinearity=gate_non_linearity,
update_nonlinearity=update_non_linearity,
wRank=wRank, uRank=uRank)
elif cell == "FastRNN":
FastCell = FastRNNCell(inputDims, hiddenDims,
update_nonlinearity=update_non_linearity,
wRank=wRank, uRank=uRank)
elif cell == "UGRNN":
FastCell = UGRNNLRCell(inputDims, hiddenDims,
update_nonlinearity=update_non_linearity,
wRank=wRank, uRank=uRank)
elif cell == "GRU":
FastCell = GRULRCell(inputDims, hiddenDims,
update_nonlinearity=update_non_linearity,
wRank=wRank, uRank=uRank)
elif cell == "LSTM":
FastCell = LSTMLRCell(inputDims, hiddenDims,
update_nonlinearity=update_non_linearity,
wRank=wRank, uRank=uRank)
else:
sys.exit('Exiting: No Such Cell as ' + cell)
FastCellTrainer = FastTrainer(FastCell, numClasses, sW=sW, sU=sU,
learningRate=learningRate, outFile=outFile,
device=device, batch_first=batch_first)
FastCellTrainer.train(batchSize, totalEpochs,
torch.from_numpy(Xtrain.astype(np.float32)),
torch.from_numpy(Xtest.astype(np.float32)),
torch.from_numpy(Ytrain.astype(np.float32)),
torch.from_numpy(Ytest.astype(np.float32)),
decayStep, decayRate, dataDir, currDir)
def main():
# Fixing seeds for reproducibility
tf.set_random_seed(42)
np.random.seed(42)
# Hyper Param pre-processing
args = helpermethods.getArgs()
# Set 'isRegression' to be True, for regression. Default is 'False'.
isRegression = args.regression
sigma = args.sigma
depth = args.depth
projectionDimension = args.proj_dim
regZ = args.rZ
regT = args.rT
regW = args.rW
regV = args.rV
totalEpochs = args.epochs
learningRate = args.learning_rate
dataDir = args.data_dir
outFile = args.output_file
(dataDimension, numClasses, Xtrain, Ytrain, Xtest, Ytest,
mean, std) = helpermethods.preProcessData(dataDir, isRegression)
sparZ = args.sZ
if numClasses > 2:
sparW = 0.2
sparV = 0.2
sparT = 0.2
else:
sparW = 1
sparV = 1
sparT = 1
if args.sW is not None:
sparW = args.sW
if args.sV is not None:
sparV = args.sV
if args.sT is not None:
sparT = args.sT
if args.batch_size is None:
batchSize = np.maximum(100, int(np.ceil(np.sqrt(Ytrain.shape[0]))))
else:
batchSize = args.batch_size
useMCHLoss = True
if numClasses == 2:
numClasses = 1
X = tf.placeholder("float32", [None, dataDimension])
Y = tf.placeholder("float32", [None, numClasses])
currDir = helpermethods.createTimeStampDir(dataDir)
helpermethods.dumpCommand(sys.argv, currDir)
helpermethods.saveMeanStd(mean, std, currDir)
# numClasses = 1 for binary case
bonsaiObj = Bonsai(numClasses, dataDimension,
projectionDimension, depth, sigma, isRegression)
bonsaiTrainer = BonsaiTrainer(bonsaiObj,
regW, regT, regV, regZ,
sparW, sparT, sparV, sparZ,
learningRate, X, Y, useMCHLoss, outFile)
sess = tf.InteractiveSession()
sess.run(tf.global_variables_initializer())
bonsaiTrainer.train(batchSize, totalEpochs, sess,
Xtrain, Xtest, Ytrain, Ytest, dataDir, currDir)
sess.close()
sys.stdout.close()
def main():
# Fixing seeds for reproducibility
tf.set_random_seed(42)
np.random.seed(42)
# Hyper Param pre-processing
args = helpermethods.getArgs()
dataDir = args.data_dir
cell = args.cell
inputDims = args.input_dim
hiddenDims = args.hidden_dim
totalEpochs = args.epochs
learningRate = args.learning_rate
outFile = args.output_file
batchSize = args.batch_size
decayStep = args.decay_step
decayRate = args.decay_rate
wRank = args.wRank
uRank = args.uRank
sW = args.sW
sU = args.sU
update_non_linearity = args.update_nl
gate_non_linearity = args.gate_nl
(dataDimension, numClasses, Xtrain, Ytrain, Xtest, Ytest, mean,
std) = helpermethods.preProcessData(dataDir)
assert dataDimension % inputDims == 0, "Infeasible per step input, " + \
"Timesteps have to be integer"
X = tf.placeholder("float",
[None, int(dataDimension / inputDims), inputDims])
Y = tf.placeholder("float", [None, numClasses])
currDir = helpermethods.createTimeStampDir(dataDir, cell)
helpermethods.dumpCommand(sys.argv, currDir)
helpermethods.saveMeanStd(mean, std, currDir)
if cell == "FastGRNN":
FastCell = FastGRNNCell(hiddenDims,
gate_non_linearity=gate_non_linearity,
update_non_linearity=update_non_linearity,
wRank=wRank,
uRank=uRank)
elif cell == "FastRNN":
FastCell = FastRNNCell(hiddenDims,
update_non_linearity=update_non_linearity,
wRank=wRank,
uRank=uRank)
else:
sys.exit('Exiting: No Such Cell as ' + cell)
FastCellTrainer = FastTrainer(FastCell,
X,
Y,
sW=sW,
sU=sU,
learningRate=learningRate,
outFile=outFile)
sess = tf.InteractiveSession()
sess.run(tf.global_variables_initializer())
FastCellTrainer.train(batchSize, totalEpochs, sess, Xtrain, Xtest, Ytrain,
Ytest, decayStep, decayRate, dataDir, currDir)
def main():
assert tf.__version__.startswith(
'2') == True, 'Only Tensorflow-2.X API is supported.'
# Hyper Param pre-processing
parser = argparse.ArgumentParser(
description='HyperParams for Bonsai Algorithm')
parser.add_argument('-dir',
'--data-dir',
required=True,
help='Data directory containing' +
'train.npy and test.npy')
parser.add_argument('-model',
'--model-dir',
required=True,
help='Model directory containing' +
'model parameter matrices and hyper-parameters')
parser.add_argument(
'-regression',
type=str2bool,
default=False,
help='boolean argument which controls whether to perform ' +
'regression or classification.' +
'default : False (Classification) values: [True, False]')
args = parser.parse_args()
# Set 'isRegression' to be True, for regression. Default is 'False'.
isRegression = args.regression
assert isRegression == False, 'Currently tflite is not supported for regression tasks.'
dataDir = args.data_dir
model_dir = args.model_dir
(dataDimension, numClasses, Xtrain, Ytrain, Xtest, Ytest, mean,
std) = helpermethods.preProcessData(dataDir, isRegression)
if numClasses == 2:
numClasses = 1
print('Model dir = ', model_dir)
Z = np.load(model_dir + 'Z.npy', allow_pickle=True)
W = np.load(model_dir + 'W.npy', allow_pickle=True)
V = np.load(model_dir + 'V.npy', allow_pickle=True)
T = np.load(model_dir + 'T.npy', allow_pickle=True)
hyperparams = np.load(model_dir + 'hyperParam.npy',
allow_pickle=True).item()
n_dim = dataDimension = hyperparams['dataDim']
projectionDimension = hyperparams['projDim']
numClasses = hyperparams['numClasses']
depth = hyperparams['depth']
sigma = hyperparams['sigma']
print('dataDim = ', dataDimension)
print('projectionDim = ', projectionDimension)
print('numClasses = ', numClasses)
print('depth = ', depth)
print('sigma = ', sigma)
dense = BonsaiLayer(numClasses, dataDimension, projectionDimension, depth,
sigma)
model = keras.Sequential([keras.Input(shape=(n_dim)), dense])
dummy_tensor = tf.convert_to_tensor(np.zeros((1, n_dim), np.float32))
out_tensor = model(dummy_tensor)
model.summary()
dense.set_weights([Z, W, V, T])
# Save the Keras model in tflite format
converter = tf.lite.TFLiteConverter.from_keras_model(model)
#converter.optimizations = [tf.lite.Optimize.DEFAULT]
tflite_model = converter.convert()
# Save the TF Lite model as file
out_tflite_model_file = model_dir + '/bonsai_model.tflite'
f = open(out_tflite_model_file, "wb")
f.write(tflite_model)
f.close()
# Delete any reference to existing models in order to avoid conflicts
del model
del tflite_model
# Prediction on an example input using tflite model we just saved
x, y = Xtrain[0], Ytrain[0]
x = x.astype(np.float32)
x = np.expand_dims(x, 0)
# Run inference with TensorFlow Lite
interpreter = tf.lite.Interpreter(model_path=out_tflite_model_file)
interpreter.allocate_tensors()
interpreter.set_tensor(interpreter.get_input_details()[0]["index"], x)
interpreter.invoke()
output = interpreter.tensor(
interpreter.get_output_details()[0]["index"])()[0]
print('true y = ', np.argmax(y))
print('predicted y = ', output)
def main():
# change cuda:0 to cuda:gpuid for specific allocation
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
# Fixing seeds for reproducibility
torch.manual_seed(42)
np.random.seed(42)
# Hyper Param pre-processing
args = helpermethods.getArgs()
sigma = args.sigma
depth = args.depth
projectionDimension = args.proj_dim
regZ = args.rZ
regT = args.rT
regW = args.rW
regV = args.rV
totalEpochs = args.epochs
learningRate = args.learning_rate
dataDir = args.data_dir
outFile = args.output_file
(dataDimension, numClasses, Xtrain, Ytrain, Xtest, Ytest, mean,
std) = helpermethods.preProcessData(dataDir)
sparZ = args.sZ
if numClasses > 2:
sparW = 0.2
sparV = 0.2
sparT = 0.2
else:
sparW = 1
sparV = 1
sparT = 1
if args.sW is not None:
sparW = args.sW
if args.sV is not None:
sparV = args.sV
if args.sT is not None:
sparT = args.sT
if args.batch_size is None:
batchSize = np.maximum(100, int(np.ceil(np.sqrt(Ytrain.shape[0]))))
else:
batchSize = args.batch_size
useMCHLoss = True
if numClasses == 2:
numClasses = 1
currDir = helpermethods.createTimeStampDir(dataDir)
helpermethods.dumpCommand(sys.argv, currDir)
helpermethods.saveMeanStd(mean, std, currDir)
# numClasses = 1 for binary case
bonsaiObj = Bonsai(numClasses, dataDimension, projectionDimension, depth,
sigma).to(device)
bonsaiTrainer = BonsaiTrainer(bonsaiObj, regW, regT, regV, regZ, sparW,
sparT, sparV, sparZ, learningRate,
useMCHLoss, outFile, device)
bonsaiTrainer.train(batchSize, totalEpochs,
torch.from_numpy(Xtrain.astype(np.float32)),
torch.from_numpy(Xtest.astype(np.float32)),
torch.from_numpy(Ytrain.astype(np.float32)),
torch.from_numpy(Ytest.astype(np.float32)), dataDir,
currDir)
sys.stdout.close()
