def Conv(var1, var2, var3, somepochs, thishighscore, X_train, Y_train, X_test,
Y_test, frame_x, frame_y):
print("Creating MultiClass Convolutional Tsetlin Machine.")
tm = MultiClassConvolutionalTsetlinMachine2D(var1, var2, var3,
(frame_x, frame_y))
print("Starting ConvTM..")
print("\nAccuracy over " + str(somepochs) + " epochs:\n")
result = 0
for i in range(somepochs):
start = time()
tm.fit(X_train, Y_train, epochs=1, incremental=True)
stop = time()
result = 100 * (tm.predict(X_test) == Y_test).mean()
print("#%d Accuracy: %.2f%% (%.2fs)" % (i + 1, result, stop - start))
# Save shit
if (result > thishighscore):
thishighscore = result
acstr = str(result)
with open("KFoldConvprint.txt", "a+") as myfile:
myfile.write("var1: " + str(var1) + " var2: " + str(var2) +
" var3: " + str(var3) + " epochs: " + str(somepochs) +
" accuracy: " + acstr + "\n")
myfile.close()
return result, thishighscore
def ConvTM(_clauses, _T, _s, _epochs, _frame_x, _frame_y):
print("Creating MultiClass Convolutional Tsetlin Machine.")
tm = MultiClassConvolutionalTsetlinMachine2D(_clauses, _T, _s, (_frame_x, _frame_y), boost_true_positive_feedback=0,
weighted_clauses=True)
print("Starting ConvTM with weighted clauses..")
print("\nAccuracy over " + str(_epochs) + " epochs:\n")
for i in range(_epochs):
start = time()
tm.fit(X_train, Y_train, epochs=1, incremental=True)
stop = time()
result = 100 * (tm.predict(X_test) == Y_test).mean()
print("#%d Accuracy: %.2f%% (%.2fs)" % (i + 1, result, stop - start))
mean_accuracy = 100 * (tm.predict(X_test) == Y_test).mean()
print("Mean Accuracy:", mean_accuracy, "\n")
print("Finished running.. \n")
return mean_accuracy
axis=0)
return X_b
unpackbit = 4
print(datetime.datetime.now())
X_train = clip_bits(X_train, unpackbit)
X_test = clip_bits(X_test, unpackbit)
print(datetime.datetime.now())
# if unpackbit%2!=0:
# break
#tm = MultiClassConvolutionalTsetlinMachine2D(8000, 200, 10.0, (7, 7))
tm = MultiClassConvolutionalTsetlinMachine2D(12000,
250,
12.0, (8, 8),
stride=3,
unpackbit=unpackbit / 2)
print("\nAccuracy over 40 epochs:\n")
for i in range(40):
start = time()
print(datetime.datetime.now())
tm.fit(X_train, Y_train, epochs=1, incremental=True)
stop = time()
print(datetime.datetime.now())
result = 100 * (tm.predict(X_test) == Y_test).mean()
print("#%d Accuracy: %.2f%% (%.2fs)" % (i + 1, result, stop - start))
print(datetime.datetime.now())
result2 = 100 * (tm.predict(X_train) == Y_train).mean()
print("#%d Accuracy: %.2f%% (%.2fs)" % (i + 1, result2, stop - start))
from keras.datasets import *
(X_train, Y_train), (X_test, Y_test) = fashion_mnist.load_data()
X_train = np.copy(X_train)
X_test = np.copy(X_test)
for i in range(X_train.shape[0]):
X_train[i, :] = cv2.adaptiveThreshold(X_train[i], 1,
cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
cv2.THRESH_BINARY, 11, 2)
for i in range(X_test.shape[0]):
X_test[i, :] = cv2.adaptiveThreshold(X_test[i], 1,
cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
cv2.THRESH_BINARY, 11, 2)
tm = MultiClassConvolutionalTsetlinMachine2D(2000,
50 * 100,
5.0, (10, 10),
weighted_clauses=True)
print("\nAccuracy over 30 epochs:\n")
for i in range(30):
start = time()
tm.fit(X_train, Y_train, epochs=1, incremental=True)
stop = time()
result = 100 * (tm.predict(X_test) == Y_test).mean()
print("#%d Accuracy: %.2f%% (%.2fs)" % (i + 1, result, stop - start))
#!/usr/local/bin/python3
from pyTsetlinMachine.tm import MultiClassConvolutionalTsetlinMachine2D
import numpy as np
from time import time
train_data = np.loadtxt("2DNoisyXORTrainingData.txt")
X_train = train_data[:, 0:-1].reshape(train_data.shape[0], 4, 4)
Y_train = train_data[:, -1]
test_data = np.loadtxt("2DNoisyXORTestData.txt")
X_test = test_data[:, 0:-1].reshape(test_data.shape[0], 4, 4)
Y_test = test_data[:, -1]
ctm = MultiClassConvolutionalTsetlinMachine2D(40,
60,
3.9, (2, 2),
boost_true_positive_feedback=0)
results = np.zeros(0)
for i in range(100):
start = time()
ctm.fit(X_train, Y_train, epochs=5000)
stop = time()
results = np.append(results, 100 * (ctm.predict(X_test) == Y_test).mean())
print(
"#%d Mean Accuracy (%%): %.2f; Std.dev.: %.2f; Training Time: %.1f ms/epoch"
% (i + 1, np.mean(results), np.std(results), (stop - start) / 5.0))
from pyTsetlinMachine.tm import MultiClassConvolutionalTsetlinMachine2D
import numpy as np
from time import time
from keras.datasets import mnist
(X_train, Y_train), (X_test, Y_test) = mnist.load_data()
X_train = np.where(X_train >= 75, 1, 0)
X_test = np.where(X_test >= 75, 1, 0)
tm = MultiClassConvolutionalTsetlinMachine2D(8000, 200, 10.0, (10, 10))
print("\nAccuracy over 40 epochs:\n")
for i in range(40):
start = time()
tm.fit(X_train, Y_train, epochs=1, incremental=True)
stop = time()
result = 100*(tm.predict(X_test) == Y_test).mean()
print("#%d Accuracy: %.2f%% (%.2fs)" % (i+1, result, stop-start))
(X_train, Y_train), (X_test, Y_test) = mnist.load_data()
# X_train = X_train[0:2]
# Y_train = Y_train[0:2]
X_train = np.where(X_train >= 75, 1, 0)
X_test = np.where(X_test >= 75, 1, 0)
#tm = MultiClassConvolutionalTsetlinMachine2D(8000, 200, 10.0, (7, 7))
unpackbit=1
tm = MultiClassConvolutionalTsetlinMachine2D(8000, 200, 10.0, (8, 8),stride=4, unpackbit=unpackbit)
print("\nAccuracy over 40 epochs:\n")
for i in range(40):
start = time()
#tm.fit(X_train, Y_train, epochs=1, incremental=True)
#stop = time()
#result = 100*(tm.predict(X_test) == Y_test).mean()
#print("#%d Accuracy: %.2f%% (%.2fs)" % (i+1, result, stop-start))
print(datetime.datetime.now())
tm.fit(X_train, Y_train, epochs=1, incremental=True)
stop = time()
X = X.reshape((entries, 19, 38))
# Answers
Y = data[:, -1]
split = 0.8
z = math.floor(len(data) * 0.8)
X_train = X[:z]
Y_train = Y[:z]
X_test = X[z:]
Y_test = Y[z:]
epochs = 20
tm = MultiClassConvolutionalTsetlinMachine2D(10000,
7500,
8.0, (19, 19),
weighted_clauses=True)
info = "; ".join(f"""
Clauses: {tm.number_of_clauses}
T: {tm.T}
s: {tm.s}
Epochs: {epochs}
Moves: 250
Games: {data.shape[0]}
""".strip().split("\n"))
total_acc = []
print(info)
print("Starting training")
#import sys
#sys.exit(1)
#------------------------------------------------------------
from pyTsetlinMachine.tm import MultiClassConvolutionalTsetlinMachine2D
print("Setting Up Machine")
clauses = int(variables["Connect4"]["Clause"])
T = variables["Connect4"]["T"]
s = variables["Connect4"]["S"]
epochs = int(variables["Connect4"]["epochs"])
ctm = MultiClassConvolutionalTsetlinMachine2D(1000,
50,
14.617627461915859, (4, 4),
weighted_clauses=True,
boost_true_positive_feedback=0)
ctm.fit(TrainX, TrainY, epochs=15)
print("Accuracy:", 100 * (ctm.predict(TestX) == TestY).mean())
def GetOutput(tm, tm_class, clause):
output = []
for i in range(84 * 2):
outputbit = tm.ta_action(tm_class, clause, i)
output.append(outputbit)
return output