def testParam(modelFunName, activateFunName, datasetName, modelWidth,
dropoutType, groupNum, keepProb, batchSize, perAverageEpoch):
###########################################
#load data
logDir = getDataSaveDir(datasetName, modelWidth, activateFunName,
dropoutType, groupNum, keepProb, perAverageEpoch,
batchSize)
all_train_data, all_train_labels, test_data, test_labels = dataset.getDataset(
datasetName, "./datasets")
all_train_data = all_train_data.astype(np.float32)
test_data = test_data.astype(np.float32)
temp_train_data, temp_train_labels = utils.shuffData(
all_train_data, all_train_labels) #return copyed data
validateDataLen = int(len(temp_train_data) * VALIDATE_RATE)
validate_data = temp_train_data[:validateDataLen, :, :, :]
validate_labels = temp_train_labels[:validateDataLen]
part_train_data = temp_train_data[validateDataLen:, :, :, :]
part_train_labels = temp_train_labels[validateDataLen:]
utils.normalizeData(all_train_data)
utils.normalizeData(part_train_data)
utils.normalizeData(validate_data)
utils.normalizeData(test_data)
if isNeedAugment(datasetName):
allTrainDataIterator = utils.AugmentDatasetLiterator(
all_train_data, all_train_labels, EPOCHSPERCHECK, batchSize,
isNeedFlip(datasetName))
partTrainDataIterator = utils.AugmentDatasetLiterator(
part_train_data, part_train_labels, EPOCHSPERCHECK, batchSize,
isNeedFlip(datasetName))
else:
allTrainDataIterator = utils.DatasetLiterator(all_train_data,
all_train_labels,
EPOCHSPERCHECK,
batchSize)
partTrainDataIterator = utils.DatasetLiterator(part_train_data,
part_train_labels,
EPOCHSPERCHECK,
batchSize)
validateDataIterator = utils.DatasetLiterator(validate_data,
validate_labels, 1,
batchSize)
testDataIterator = utils.DatasetLiterator(test_data, test_labels, 1,
batchSize)
################################################
#build model
imageShape = list(temp_train_data.shape)
imageShape[0] = None
imagePlaceholder = tf.placeholder(tf.float32, imageShape)
labelPlaceholder = tf.placeholder(tf.int32, [None])
isTrainPlaceholder = tf.placeholder(tf.bool)
learningRatePlaceholder = tf.placeholder(tf.float32, name="learningRate")
validateErrPlaceholder = tf.placeholder(tf.float32)
modelFun = getModelFun(modelFunName)
logits, combineOps, averageOps = modelFun(
imagePlaceholder, modelWidth, dataset.getDatasetClassNum(datasetName),
getActivateFun(activateFunName), dropoutType, groupNum, keepProb,
isTrainPlaceholder)
loss = tf.losses.sparse_softmax_cross_entropy(labels=labelPlaceholder,
logits=logits)
predictions = tf.cast(tf.argmax(logits, axis=1), tf.int32)
accuracy = tf.reduce_mean(
tf.cast(tf.equal(predictions, labelPlaceholder), tf.float32))
optimizer = tf.train.AdamOptimizer(learning_rate=learningRatePlaceholder)
trainOp = optimizer.minimize(loss)
saver = tf.train.Saver(getSaveVariable())
tf.summary.scalar("1_accurate_", accuracy)
tf.summary.scalar("2_loss_", loss)
tf.summary.scalar("3_learningRate_", learningRatePlaceholder)
tf.summary.scalar("4_validateErr_", validateErrPlaceholder)
merged = tf.summary.merge_all()
train_writer = tf.summary.FileWriter(logDir, graph=tf.get_default_graph())
tensorMap = {
"predictions": predictions,
"isTrainPlaceholder": isTrainPlaceholder,
"imagePlaceholder": imagePlaceholder,
"labelPlaceholder": labelPlaceholder,
"loss": loss,
"accuracy": accuracy,
"merged": merged,
"trainOp": trainOp,
"learningRatePlaceholder": learningRatePlaceholder,
"train_writer": train_writer,
"combineOps": combineOps,
"averageOps": averageOps,
"saver": saver,
"validateErrPlaceholder": validateErrPlaceholder
}
####################################################
config = tf.ConfigProto()
config.gpu_options.per_process_gpu_memory_fraction = (GPU_MEMORY_USE) / (
PARALLEL_RANK)
session = tf.Session(config=config)
session.run([tf.global_variables_initializer()])
modelPath = getModelSavePath(datasetName, modelWidth, activateFunName,
dropoutType, groupNum, keepProb,
perAverageEpoch, batchSize)
errs = []
supConfigs = []
#globalAutoTuner = utils.GlobalLearningRateTuner(STARTLREANINGRATE)
localAutoTuner = utils.LocalLearningRateTuner(STARTLREANINGRATE,
maxDontSave=7)
autoTuners = [localAutoTuner]
#find train param base on validate data
if USE_AUTO_TUNER:
for autoTuner in autoTuners:
session.run([tf.global_variables_initializer()])
trainModel(session, partTrainDataIterator, validateDataIterator,
autoTuner, tensorMap, perAverageEpoch, modelPath,
logDir)
saver.restore(session, modelPath) # load early stop model
errs.append(computErr(session, testDataIterator, tensorMap))
if IS_RETRAIN_ON_ALL_TRAINSET:
supConfigs.append((autoTuner.getFixTuner(),
allTrainDataIterator, testDataIterator))
else:
fixTuner1 = utils.getFixLearningRateTuner([10, 10], [1e-3, 1e-4],
isEarlyStop=False)
supConfigs.append((fixTuner1, allTrainDataIterator, testDataIterator))
for tuner, trainIterator, validateIterator in supConfigs:
session.run([tf.global_variables_initializer()])
trainModel(session, trainIterator, validateIterator, tuner, tensorMap,
perAverageEpoch, modelPath, logDir)
saver.restore(session, modelPath) #load model
errs.append(computErr(session, testDataIterator, tensorMap))
session.close()
if len(errs) == 0:
raise Exception("config error")
return [min(errs)]
def testFullConnectedNNOnMnist():
trainData, trainLabel, testData, testLabel = dataset.getDataset(
"MNIST", "./datasets")
trainData = trainData.astype(np.float32)
testData = testData.astype(np.float32)
utils.normalizeData(trainData)
utils.normalizeData(testData)
trainDataIterator = utils.DatasetLiterator(trainData, trainLabel, 50,
BATCH_SIZE)
testDataIterator = utils.DatasetLiterator(testData, testLabel, 1,
BATCH_SIZE)
imagePlaceholder = Placeholder("image", [-1, 28 * 28])
labelPlaceholder = Placeholder("label", [-1, 10])
bathSizePlaceholder = Placeholder("batch size", [1])
learningRatePlaceholder = Placeholder("learning rate", [1])
output = imagePlaceholder
output = denseLayer(output, 128, "layer1")
output = ReluNode("relu1", [output])
output = denseLayer(output, 128, "layer2")
output = ReluNode("relu2", [output])
logits = denseLayer(output, 10, "layer3")
predictLabel = softmax(logits, "softmax")
loss = meanCrossEntropy(predictLabel, labelPlaceholder,
bathSizePlaceholder, "loss")
gradientPairs = minimize(loss)
trainOp = SGDNode("train op", gradientPairs, learningRatePlaceholder)
step = 0
learningRate = np.array([1e-2])
bathSize = np.array([BATCH_SIZE])
for image, label in trainDataIterator.getNextBatch():
image = np.reshape(image, [-1, 28 * 28])
label = getOneHotLabel(label, 10)
feedDic = {
imagePlaceholder.getName(): image,
labelPlaceholder.getName(): label,
bathSizePlaceholder.getName(): bathSize,
learningRatePlaceholder.getName(): learningRate
}
setFeedDic(feedDic)
trainOp.getValue()
step += 1
if step % 100 == 0:
print("loss:" + str(loss.getValue()[0]))
testCount = 0
errorCount = 0
for image, label in testDataIterator.getNextBatch():
image = np.reshape(image, [-1, 28 * 28])
feedDic = {imagePlaceholder.getName(): image}
setFeedDic(feedDic)
predict = predictLabel.getValue()
predict = np.argmax(predict, -1)
testCount += len(label)
errorCount += sum((predict != label).astype(np.int32))
print("\n\n")
print("error rate:" + str(errorCount / testCount))
def testCNNOnCIAFR():
trainData, trainLabel, testData, testLabel = dataset.getDataset(
"SVHN", "./datasets")
trainData = trainData.astype(np.float32)
testData = testData.astype(np.float32)
utils.normalizeData(trainData)
utils.normalizeData(testData)
trainDataIterator = utils.DatasetLiterator(trainData, trainLabel, 10,
BATCH_SIZE)
testDataIterator = utils.DatasetLiterator(testData, testLabel, 1,
BATCH_SIZE)
imagePlaceholder = Placeholder("image", [-1, 32, 32, 3])
labelPlaceholder = Placeholder("label", [-1, 10])
bathSizePlaceholder = Placeholder("batch size", [1])
learningRatePlaceholder = Placeholder("learning rate", [1])
output = imagePlaceholder
output = convLayer(output, 3, 2, 32, "layer1")
output = ReluNode("relu1", [output])
output = convLayer(output, 3, 2, 64, "layer2")
output = ReluNode("relu2", [output])
output = convLayer(output, 3, 2, 128, "layer3")
output = ReluNode("relu3", [output])
print("last conv feature size:" + str(output.getShape()))
avgPoolSize = max(output.getShape()[1], output.getShape()[2])
output = avgPool(output, avgPoolSize, 1, "globalPool")
output = ReshapeOp("reshape", [output, np.array([-1, 128])])
logits = denseLayer(output, 10, "logits")
predictLabel = softmax(logits, "softmax")
loss = meanCrossEntropy(predictLabel, labelPlaceholder,
bathSizePlaceholder, "loss")
gradientPairs = minimize(loss)
trainOp = MomentumSGDNode("train op", gradientPairs,
learningRatePlaceholder,
ConstValueNode("moment", np.array([0.9])))
step = 0
learningRate = np.array([1e-2])
bathSize = np.array([BATCH_SIZE])
nodes = [
node for node in getNodeByConstructSeq()
if "const" not in node.getName() and "batch" not in node.getName()
]
for image, label in trainDataIterator.getNextBatch():
label = getOneHotLabel(label, 10)
feedDic = {
imagePlaceholder.getName(): image,
labelPlaceholder.getName(): label,
bathSizePlaceholder.getName(): bathSize,
learningRatePlaceholder.getName(): learningRate
}
setFeedDic(feedDic)
trainOp.getValue()
# for node in nodes:
# name=node.getName()
# value=node.getValue()
# shape=value.shape
# pass
step += 1
print("step:" + str(step) + " loss:" + str(loss.getValue()[0]))
testCount = 0
errorCount = 0
for image, label in testDataIterator.getNextBatch():
feedDic = {imagePlaceholder.getName(): image}
setFeedDic(feedDic)
predict = predictLabel.getValue()
predict = np.argmax(predict, -1)
testCount += len(label)
errorCount += sum((predict != label).astype(np.int32))
print("\n\n")
print("error rate:" + str(errorCount / testCount))
from utils import loadData, normalizeData, degexpand
import numpy as np
import matplotlib.pyplot as plt
# LOAD THE DATA AND EDIT IT:
# ==========================
[t, X] = loadData()
X_n = normalizeData(X)
t = normalizeData(t)
# CREATE THE TRAIN AND TEST SETS:
# ================================
TRAIN_SIZE = 100 # number of training examples
xTrain = X_n[np.arange(0, TRAIN_SIZE), :] # training input data
tTrain = t[np.arange(0, TRAIN_SIZE)] # trainint output data
xTest = X_n[np.arange(TRAIN_SIZE, X_n.shape[0]), :] # testing input data
tTest = t[np.arange(TRAIN_SIZE, X_n.shape[0])] # testing output data
trainErrors = [0] * 10
testErrors = [0] * 10
for i in np.arange(1, 11):
pTrain = degexpand(xTrain, i)
w = np.dot(np.linalg.pinv(np.dot(np.transpose(pTrain), pTrain)),
np.dot(np.transpose(pTrain), tTrain))
trainDifference = np.dot(pTrain, w) - tTrain
trainError = (np.mean(np.square(trainDifference)))
pTest = degexpand(xTest, i)
testDifference = np.dot(pTest, w) - tTest
## Merge multiple occurence of coupon from multiple cities
## Return allCouponList
def mergeCouponLists(allCouponList, couponList):
if (allCouponList != []):
for coupon in couponList:
idx = checkCouponOccurence(coupon, allCouponList)
if (idx == -1):
allCouponList.append(coupon)
else:
allCouponList[idx]['customer_city'] += coupon['customer_city']
else:
allCouponList = couponList
return allCouponList
## Main Program
if __name__ == '__main__':
print(' ~=~ Coupon Data Scrapper ~=~ ')
print(' Source: MyFave.com ')
# Control arguments
cities, isRequestAll = utils.controlArgv(cities)
random.shuffle(cities)
# Scrape data from various cities
allCouponList = scrapeAllCoupons(cities, isRequestAll)
# Save to File
utils.saveJSONToFile(allCouponList)
# Transform to normalized JSON
utils.normalizeData(allCouponList)
import utils as utils
import numpy as np
import matplotlib.pyplot as plt
[t, X] = utils.loadData()
X_n = utils.normalizeData(X)
t = utils.normalizeData(t)
# CREATE THE TRAIN AND TEST SETS:
# ================================
TRAIN_SIZE = 100 # number of training examples
xTrain = X_n[np.arange(0, TRAIN_SIZE), :] # training input data
tTrain = t[np.arange(0, TRAIN_SIZE)] # training output data
xTest = X_n[np.arange(TRAIN_SIZE, X_n.shape[0]), :] # testing input data
tTest = t[np.arange(TRAIN_SIZE, X_n.shape[0])] # testing output data
tTest = tTest.reshape(292, 1)
trainErrors = dict()
testErrors = dict()
xTrainFeature = xTrain[:, 2].reshape(100, 1)
xTestFeature = xTest[:, 2].reshape(292, 1)
degrees = [2, 10, 12]
# calculate train and test error for each feature with different polynomial degrees
for i in degrees:
pTrain = utils.degexpand(xTrainFeature, i)
w = np.dot(np.linalg.pinv(pTrain), tTrain)