def run_all(gpu=False, double_precision=False):
print("\nLasso.")
print "Solve time:\t{:.2e} seconds\n".format(
Lasso(200, 2000, gpu=gpu, double_precision=double_precision))
print("\nLasso Path.")
print "Solve time:\t{:.2e} seconds\n".format(
LassoPath(200, 1000, gpu=gpu, double_precision=double_precision))
print("\nLogistic Regression.")
print "Solve time:\t{:.2e} seconds\n".format(
Logistic(1000, 100, gpu=gpu, double_precision=double_precision))
print("\nLinear Program in Equality Form.")
print "Solve time:\t{:.2e} seconds\n".format(
LpEq(1000, 200, gpu=gpu, double_precision=double_precision))
print("\nLinear Program in Inequality Form.")
print "Solve time:\t{:.2e} seconds\n".format(
LpIneq(1000, 200, gpu=gpu, double_precision=double_precision))
print("\nNon-Negative Least Squares.")
print "Solve time:\t{:.2e} seconds\n".format(
NonNegL2(1000, 200, gpu=gpu, double_precision=double_precision))
print("\nSupport Vector Machine.")
print "Solve time:\t{:.2e} seconds\n".format(
Svm(1000, 200, gpu=gpu, double_precision=double_precision))
def recognize():
with AudioRecorder(rate=conf.sampling_rate) as recorder:
svm = Svm()
with open('trained_data.pickle.b64') as f:
svm.import_model(f.read())
while True:
print()
print('\x1b[A\x1b[2K' 'Press Enter to start recording or Ctrl+C to exit')
input()
recorder.start_recording()
print('\x1b[A\x1b[2K' '\x1b[31mREC\x1b[0m Press Enter to stop recording')
input()
data = list(recorder.bytes_to_numseq(recorder.finish_recording()))
transformed_data = list(sliding_diff(data, conf.sliding_diff_winsize))
scaled_data = scale_array(transformed_data, conf.svm_inputs)
pred = svm.get(scaled_data)
print('\x1b[A\x1b[2K' 'Predicted output: {}'.format(pred))
def learn():
labels = get_labels()
# mlr = MultiLogisticRegression(labels, conf.lr_inputs)
svm = Svm()
dataset = list(read_examples('data'))
rd.shuffle(dataset)
m = len(dataset)
train_m = int(0.7 * m)
train_set = dataset[:train_m]
test_set = dataset[train_m:]
test_m = len(test_set)
print('Learning...')
svm.learn(train_set)
print('Learnt')
correct = 0
for x, y in train_set:
pred = svm.get(x)
if pred == y:
correct += 1
print('Results on train set: {:2f}% accuracy'.format(100 * correct / train_m))
correct = 0
for x, y in test_set:
pred = svm.get(x)
if pred == y:
correct += 1
print('Results on test set: {:2f}% accuracy'.format(100 * correct / test_m))
with open('trained_data.pickle.b64', 'w') as wf:
wf.write(svm.export_model())
print('Weights written to trained_data.pickle.b64')
def display_f_test(inputs_from_feature_selection, dataset):
print("ftest results: (f, p) =")
print(
" NN, KNN: ",
combined_ftest_5x2cv(NeuralNet(10000).clf,
Knn(2).clf,
inputs_from_feature_selection,
dataset.target,
random_seed=1))
print(
" NN, SVM: ",
combined_ftest_5x2cv(NeuralNet(10000).clf,
Svm().clf,
inputs_from_feature_selection,
dataset.target,
random_seed=1))
print(
" KNN, SVM: ",
combined_ftest_5x2cv(Knn(2).clf,
Svm().clf,
inputs_from_feature_selection,
dataset.target,
random_seed=1))
def run(self, x, nbit, resolution, error):
nbits = str(nbit)
test_data = np.load("./data/" + nbits + "bit" + "/" + nbits + "bit" +
"_" + str(resolution) + "x" + str(resolution) +
"_test_images.npy")
train_data = np.load("./data/" + nbits + "bit" + "/" + nbits + "bit" +
"_" + str(resolution) + "x" + str(resolution) +
"_train_images.npy")
x = int(x)
if (error != 0):
test_data = np.array(
[self.pixel_bit_error(error, i, nbit) for i in test_data])
if (x == 1):
generations = input("enter the number of generations")
batchSize = input("enter the size of each batch")
generations = int(generations)
batchSize = int(batchSize)
Jesus = Cnn()
Jesus.run(train_data, test_data, resolution, error, generations,
batchSize)
if (x == 2):
if (error != 0):
train_data = np.array(
[self.pixel_bit_error(error, i, nbit) for i in train_data])
Jesus = Svm()
Jesus.run(train_data, test_data, resolution)
if (x == 3):
if (error != 0):
train_data = np.array(
[self.pixel_bit_error(error, i, nbit) for i in train_data])
k = input("k ?")
k = int(k)
Jesus = Knn(k)
Jesus.run(train_data, test_data, resolution)
if (x == 4):
Jesus = Caliente([], error)
batchSize = input("enter the size of each batch")
generations = input("enter the number of generations")
generations = int(generations)
batchSize = int(batchSize)
Jesus.run(train_data, test_data, resolution, generations,
batchSize)
xTest = np.hstack([xTest, np.ones((xTest.shape[0], 1))])
print('Train image shape after add bias column: {0}'.format(xTrain.shape))
print('Val image shape after add bias column: {0}'.format(xVal.shape))
print('Test image shape after add bias column: {0}'.format(xTest.shape))
print(
'\n##############################################################################################'
)
######################################################################################################
# SVM CLASSIFIER #
######################################################################################################
from svm import Svm
numClasses = np.max(yTrain) + 1
print('Start training Svm classifier')
classifier = Svm(xTrain.shape[1], numClasses)
# Show weight for each class before training
if classifier.W is not None:
tmpW = classifier.W[:-1, :]
tmpW = tmpW.reshape(32, 32, 3, 10)
tmpWMin, tmpWMax = np.min(tmpW), np.max(tmpW)
for i in range(numClasses):
plt.subplot(2, 5, i + 1)
plt.title(classesName[i])
wPlot = 255.0 * (tmpW[:, :, :, i].squeeze() - tmpWMin) / (tmpWMax -
tmpWMin)
plt.imshow(wPlot.astype('uint8'))
plt.savefig(baseDir + 'svm1.png')
plt.clf()
from probcpredict import Probcpredict
from kfoldcv import Kfoldcv
from bootstrapping import Bootstrapping
from hypotest import Hypotest
#case 2_1
np.set_printoptions(precision=4)
X = np.array([[-3, 2],
[-2, 1.5],
[-1, 1],
[0, 0.5],
[1, 0]])
y = np.array([[1], [1], [1], [-1], [-1]])
pe=Perceptron(10,X,y)
theta_perceptron, num = pe.perceptron()
sv=Svm(X,y)
theta_svm = sv.svm()
pr=Predict(theta_perceptron,np.array([[1], [-2]]))
print("From preceptron algorithm, the theta is:",theta_perceptron,"using direction [[1], [-2]], it will be predicted as:",pr.predict())
pr2=Predict(theta_svm,np.array([[1], [-2]]))
print("From svm, the theta is:",theta_svm,"using direction [[1], [-2]], it will be predicted as:",pr2.predict())
#case 3_1
np.set_printoptions(precision=4)
X = np.array([[-3, 2],
[-2, 1.5],
[-1, 1],
[0, 0.5],
[1, 0]])
y = np.array([[1], [1], [1], [-1], [-1]])
def evaluateSvm(X_train, X_test, y_train, y_test):
svm = Svm()
return evaluate_classifier(svm, X_train, X_test, y_train, y_test)
xTest = np.hstack([xTest, np.ones((xTest.shape[0], 1))])
print('Train image shape after add bias column: {0}'.format(xTrain.shape))
print('Val image shape after add bias column: {0}'.format(xVal.shape))
print('Test image shape after add bias column: {0}'.format(xTest.shape))
print(
'\n##############################################################################################'
)
######################################################################################################
# SVM CLASSIFIER #
######################################################################################################
from svm import Svm
numClasses = np.max(yTrain) + 1
print('Start training Svm classifier')
classifier = Svm(xTrain.shape[1], numClasses)
# Show weight for each class before training
if classifier.W is not None:
tmpW = classifier.W[:-1, :]
tmpW = tmpW.reshape(32, 32, 3, 10)
tmpWMin, tmpWMax = np.min(tmpW), np.max(tmpW)
for i in range(numClasses):
plt.subplot(2, 5, i + 1)
plt.title(classesName[i])
wPlot = 255.0 * (tmpW[:, :, :, i].squeeze() - tmpWMin) / (tmpWMax -
tmpWMin)
plt.imshow(wPlot.astype('uint8'))
plt.savefig(baseDir + 'svm1.png')
plt.clf()
def main():
# files names
x_train_name = sys.argv[1]
y_train_name = sys.argv[2]
x_test_name = sys.argv[3]
# y_test_name = "test_y.txt" # todo
# read data
train_x = read_points(x_train_name)
train_y = read_labels(y_train_name)
test_x = read_points(x_test_name)
# test_y = read_labels(y_test_name) # todo
try:
# try to normalize according mean and std
mean, std = get_mean_std(train_x)
train_x = apply_mean_std_bias(train_x, mean, std)
test_x = apply_mean_std_bias(test_x, mean, std)
# try to normalize according min and max
# min, max = get_min_max(train_x)
# train_x = apply_min_max_bias(train_x, min, max)
# test_x = apply_min_max_bias(test_x, min, max)
except:
nothing = "nothing"
# prepare set
train_set = list(zip(train_x, train_y))
# test_set = list(zip(test_x, test_y)) # todo
# choose better (probably) trained
max_accs, best_algos = [0, 0, 0], [None, None, None]
num_tries = 10
for i in range(num_tries):
try:
algos = [
Perceptron(list(train_set), list(test_x), 5, 0.01),
Svm(list(train_set), list(test_x), 10, 0.01, 0.001),
Pa(list(train_set), list(test_x), 10)
]
accs, vaccs = [], []
for algo in algos:
algo.train()
accs.append(algo.validate(train_set))
# vaccs.append(algo.k_cross_validation()) # todo
# print(accs)
# print(vaccs)
# print("\n")
# take algo of better acc
for i in range(len(algos)):
if accs[i] > max_accs[i]:
best_algos[i], max_accs[i] = algos[i], accs[i]
except:
nothing = "nothing"
# print([best_algos[0].validate(train_set),
# best_algos[1].validate(train_set),
# best_algos[2].validate(train_set)])
# print([best_algos[0].validate(test_set),
# best_algos[1].validate(test_set),
# best_algos[2].validate(test_set)])
for best_alg in best_algos:
best_alg.predict_all()
printing_format(best_algos[0].test_y, best_algos[1].test_y,
best_algos[2].test_y)
xTest = np.hstack([xTest, np.ones((xTest.shape[0], 1))])
print('Train image shape after add bias column: {0}'.format(xTrain.shape))
print('Val image shape after add bias column: {0}'.format(xVal.shape))
print('Test image shape after add bias column: {0}'.format(xTest.shape))
print(
'\n##############################################################################################'
)
######################################################################################################
# SVM CLASSIFIER #
######################################################################################################
from svm import Svm
numClasses = np.max(yTrain) + 1
print('Start training Svm classifier')
classifier = Svm(xTrain.shape[1], numClasses)
# Show weight for each class before training
if classifier.W is not None:
tmpW = classifier.W[:-1, :]
tmpW = tmpW.reshape(32, 32, 3, 10)
tmpWMin, tmpWMax = np.min(tmpW), np.max(tmpW)
for i in range(numClasses):
plt.subplot(2, 5, i + 1)
plt.title(classesName[i])
wPlot = 255.0 * (tmpW[:, :, :, i].squeeze() - tmpWMin) / (tmpWMax -
tmpWMin)
plt.imshow(wPlot.astype('uint8'))
plt.savefig(baseDir + 'svm1.png')
plt.clf()
def builder(c, vectors, classes):
return Svm(c, vectors, classes)
xTrain = np.hstack([xTrain, np.ones((xTrain.shape[0], 1))])
xVal = np.hstack([xVal, np.ones((xVal.shape[0], 1))])
xTest = np.hstack([xTest, np.ones((xTest.shape[0], 1))])
print ('Train image shape after add bias column: {0}'.format(xTrain.shape))
print ('Val image shape after add bias column: {0}'.format(xVal.shape))
print ('Test image shape after add bias column: {0}'.format(xTest.shape))
print ('\n##############################################################################################')
######################################################################################################
# SVM CLASSIFIER #
######################################################################################################
from svm import Svm
numClasses = np.max(yTrain) + 1
print ('Start training Svm classifier')
classifier = Svm(xTrain.shape[1], numClasses)
# Show weight for each class before training
if classifier.W is not None:
tmpW = classifier.W[:-1, :]
tmpW = tmpW.reshape(32, 32, 3, 10)
tmpWMin, tmpWMax = np.min(tmpW), np.max(tmpW)
for i in range(numClasses):
plt.subplot(2, 5, i+1)
plt.title(classesName[i])
wPlot = 255.0 * (tmpW[:, :, :, i].squeeze() - tmpWMin) / (tmpWMax - tmpWMin)
plt.imshow(wPlot.astype('uint8'))
plt.savefig(baseDir+'svm1.png')
plt.clf()
# Training classifier
print('Train image shape after add bias column: {0}'.format(xTrain.shape))
print('Val image shape after add bias column: {0}'.format(xVal.shape))
print('Test image shape after add bias column: {0}'.format(xTest.shape))
print(
'\n##############################################################################################'
)
######################################################################################################
# SVM CLASSIFIER #
######################################################################################################
from svm import Svm
numClasses = np.max(yTrain) + 1
print('Start training Svm classifier')
classifier = Svm(xTrain.shape[1], numClasses)
# Show weight for each class before training
if classifier.W is not None:
tmpW = classifier.W[:-1, :]
tmpW = tmpW.reshape(32, 32, 3, 10)
tmpWMin, tmpWMax = np.min(tmpW), np.max(tmpW)
for i in range(numClasses):
plt.subplot(2, 5, i + 1)
plt.title(classesName[i])
wPlot = 255.0 * (tmpW[:, :, :, i].squeeze() - tmpWMin) / (tmpWMax -
tmpWMin)
plt.imshow(wPlot.astype('uint8'))
plt.savefig(baseDir + 'svm1.png')
plt.clf()
# update weights and biases
optimizer.update_params(L1)
optimizer.update_params(L2)
print('predictions: ')
print(predictions)
confusion_nn = confusion_matrix(Y, predictions)
fig2 = plt.figure()
df_cm = pd.DataFrame(confusion_nn, range(num_classes),
range(num_classes))
# plt.figure(figsize=(10,7))
sn.set(font_scale=1.4) # for label size
sn.heatmap(df_cm, annot=True, annot_kws={"size": 16}) # font size
if model_selector[2]:
SVM = Svm(X, Y, 0.5, 50)
SVM.fit(num_classes)
SVM.ecoc_predict(X)
predictions = np.array(SVM.ecoc_predict)
print(predictions)
print(Y)
print("acc: %f" % np.mean(SVM.ecoc_predict == Y))
confusion_svm = confusion_matrix(Y, predictions)
fig3 = plt.figure()
df_cm = pd.DataFrame(confusion_svm, range(num_classes),
range(num_classes))
# plt.figure(figsize=(10,7))
sn.set(font_scale=1.4) # for label size
sn.heatmap(df_cm, annot=True, annot_kws={"size": 16}) # font size
plt.show()