def run(self, X_train, X_test, y_train, classes):
wsds = {}
for label in classes:
wsds[label] = wp.ClusWisard(self.addr_size, self.minScore,
self.threshold,
self.discriminatorLimit)
start_time = time.time()
for i in range(len(X_train)):
ds = wp.DataSet()
if label in y_train[i]:
ds.add(wp.BinInput(X_train[i]), "true")
wsds[label].train(ds)
else:
ds.add(wp.BinInput(X_train[i]), "false")
wsds[label].train(ds)
self.training_time.append(time.time() - start_time)
y_pred = [[]] * len(X_test)
ds_test = wp.DataSet()
for i in range(len(X_test)):
ds_test.add(X_test[i])
for label in classes:
start_time = time.time()
outputs = wsds[label].classify(ds_test)
self.classification_time.append(
(time.time() - start_time) / len(X_test))
for i in range(len(outputs)):
if outputs[i] == "true":
y_pred[i].append(label)
return y_pred
def test_classify_unsupervised(self):
try:
clus = wp.ClusWisard(3, 0.1, 10, 5)
clus.trainUnsupervised(self.X)
out = clus.classifyUnsupervised(self.X)
except RuntimeError and TypeError:
self.fail("unsupervised classify test fail!")
def run(self, X_train, X_test, y_train, classes):
clus = wp.ClusWisard(self.addr_size, self.minScore, self.threshold,
self.discriminatorLimit)
for i, y in enumerate(y_train):
start_time = time.time()
y.sort()
y_ps = "-".join(y)
ds = wp.DataSet()
ds.add(wp.BinInput(X_train[i]), y_ps)
clus.train(ds)
self.training_time.append(time.time() - start_time)
y_pred_ps = []
for x in X_test:
start_time = time.time()
ds_test = wp.DataSet()
ds_test.add(x)
y_pred_ps.append(clus.classify(ds_test)[0])
self.classification_time.append(time.time() - start_time)
y_pred = []
for y in y_pred_ps:
y_pred.append(y.split("-"))
return y_pred
def test_json_supervised(self):
try:
clus = wp.ClusWisard(3, 0.1, 10, 5)
clus.train(self.X, self.y)
out = clus.json()
import sys
if sys.version_info[0] < 3:
self.assertIsInstance(out, unicode)
else:
self.assertIsInstance(out, str)
out2 = json.loads(out)
clus2 = wp.ClusWisard(out)
self.assertSequenceEqual(clus.classify(self.X),
clus2.classify(self.X))
except RuntimeError and TypeError:
self.fail("supervised json test fail!")
def random_model(self):
if (random.randint(0, 1)) % 2 == 0:
net = wp.Wisard(np.random.randint(LOW_N, HIGH_N))
else:
discriminator_limit = np.random.randint(2, MAX_DISCRIMINATOR_LIMIT)
net = wp.ClusWisard(np.random.randint(LOW_N, HIGH_N), MIN_SCORE,
GROW_INTERVAL, discriminator_limit)
return net
def test_classify_supervised(self):
try:
clus = wp.ClusWisard(3, 0.1, 10, 5)
clus.train(self.X, self.y)
out = clus.classify(self.X)
self.assertSequenceEqual(out, self.y)
except RuntimeError and TypeError:
self.fail("supervised classify test fail!")
def test_classify_semisupervised(self):
try:
clus = wp.ClusWisard(3, 0.1, 10, 5)
clus.train(self.X, self.y2)
out = clus.classify(self.X)
out2 = {k: out[k] for k in self.y2.keys()}
self.assertSequenceEqual(out2, self.y2)
except RuntimeError and TypeError:
self.fail("semisupervised classify test fail!")
def test_build(self):
try:
addressSize = 3
minScore = 0.1
threshold = 10
discriminatorLimit = 5
clus = wp.ClusWisard(addressSize, minScore, threshold,
discriminatorLimit)
self.assertIsInstance(clus, wp.ClusWisard)
except RuntimeError and TypeError:
self.fail("cluswisard instantiation failed!")
for idx2, j in enumerate(Xaux3[idx1]): # percorrer elementos e respetivos indices contidos na sublista, aqui enumerate(i) tambem daria
if(j <= threshold and j>1):
Xaux3[idx1][idx2] = 0
print("Separando os elementos em conjuntos...")
X_train, X_test, y_train, y_test = Xaux3[:60000].astype(int), Xaux3[60000:].astype(int), yaux[:60000], yaux[60000:]
n_folds = 3
address=30
minScore = 0.1
discriminatorLimit = 5
print("Número de folds: ", n_folds)
print("Address Size: ", address)
print("MinScore:", minScore)
print("discriminatorLimit:", discriminatorLimit)
clus = wp.ClusWisard(address, minScore, threshold, discriminatorLimit, verbose=False)
kfold = KFold(n_folds, shuffle=True)
acuracia_list = []
acertos_list = []
for train_ix, test_ix in kfold.split(X_train):
trainX, trainY, testX, testY = X_train[train_ix], y_train[train_ix], X_train[test_ix], y_train[test_ix]
print("vai treinar")
clus.train(trainX, trainY)
print("treinou")
out = clus.classify(testX)
print("classificou")
# acertos=0
# for i, d in enumerate(testY):
dtherm = wsd.DynamicThermometer(therm, mins, maxs)
binX = [
dtherm.transform(densemtx[i].tolist()[0]) for i in range(dbmatrix.shape[0])
]
for train_index, test_index in skf.split(dbmatrix, labels):
for n in range(1, 11):
win = n * 3
print("TRAIN - " + str(len(train_index)))
print("TEST - " + str(len(test_index)))
ds_train = wsd.DataSet([binX[ix] for ix in train_index],
[labels[ix] for ix in train_index])
ds_test = wsd.DataSet([binX[ix] for ix in test_index],
[labels[ix] for ix in test_index])
wisard = wsd.ClusWisard(win, 0.7, 20, 10)
wisard.train(ds_train)
outTrain = np.array(wisard.classify(ds_train))
outTest = np.array(wisard.classify(ds_test))
print('Train accuracy:',
accuracy_score(outTrain, [labels[ix] for ix in train_index]))
print('Test accuracy:',
accuracy_score(outTest, [labels[ix] for ix in test_index]))
wisard = wsd.ClusWisard(win, 0.7, 20, 10)
wisard.train(ds_test)
outTrain = np.array(wisard.classify(ds_train))
outTest = np.array(wisard.classify(ds_test))
print('Train accuracy:',
accuracy_score(outTrain, [labels[ix] for ix in train_index]))
print('Test accuracy:',
def random_clus(self):
discriminator_limit = np.random.randint(2, MAX_DISCRIMINATOR_LIMIT)
return wp.ClusWisard(np.random.randint(LOW_N, HIGH_N), MIN_SCORE,
GROW_INTERVAL, discriminator_limit)
def random_wisard(self):
return wp.ClusWisard(np.random.randint(LOW_N, HIGH_N), 0.1, 10, 1)
def test_train_semisupervised(self):
try:
clus = wp.ClusWisard(3, 0.1, 10, 5)
clus.train(self.X, self.y2)
except RuntimeError and TypeError:
self.fail("semisupervised train test fail!")
def test_train_unsupervised(self):
try:
clus = wp.ClusWisard(3, 0.1, 10, 5)
clus.trainUnsupervised(self.X)
except RuntimeError and TypeError:
self.fail("unsupervised train test fail!")
Y_te = list(map(str, Y_te))
Y_vl = list(map(str, Y_vl))
# ************************** 3. WISARD MODEL **************************
Acc_te = np.array([]) # accuracy matrix (test dataset)
Acc_vl = np.array([]) # accuracy matrix (test dataset)
T_tr = np.array([]) # train time matrix
T_te = np.array([]) # classification time matrix (test dataset)
R_wsd_te = np.array([]) # wisard return matrix (test dataset)
R_wsd_vl = np.array([]) # wisard return matrix (test dataset)
for n in range(N):
# Model initialiation
wsd = wp.ClusWisard(addressSize, minScore, threshold, discriminatorLimit)
# Batch training
startTime = time.time()
wsd.train(X_tr, Y_tr)
endTime = time.time()
T_tr_n = endTime - startTime
T_tr = np.append(T_tr, T_tr_n)
G_te = [] # predicted output (test dataset)
startTime = time.time()
# On-line traning and classification
if onlineTraining:
for k in range(len(X_te)):
x = X_te[k]
dtherm = wsd.DynamicThermometer(therm, mins, maxs)
binX = [dtherm.transform(densemtx[i].tolist()[0]) for i in range(dbmatrix.shape[0])]
skf = StratifiedKFold(n_splits=10, shuffle=True)
for train_index, test_index in skf.split(dbmatrix, labels):
print("TRAIN - "+str(len(train_index)))
print("TEST - "+str(len(test_index)))
ds_train = wsd.DataSet([binX[ix] for ix in train_index],[labels[ix] for ix in train_index])
ds_test = wsd.DataSet([binX[ix] for ix in test_index], [labels[ix] for ix in test_index])
print("WISARD"+str(15))
wisard = wsd.ClusWisard(15, 0.7, 20, 20)
wisard.train(ds_train)
outTrain = np.array(wisard.classify(ds_train))
outTest = np.array(wisard.classify(ds_test))
print('Train accuracy:', accuracy_score(outTrain, [labels[ix] for ix in train_index]))
print('Test accuracy:', accuracy_score(outTest, [labels[ix] for ix in test_index]))
wisard = wsd.ClusWisard(15, 0.7, 20, 20)
wisard.train(ds_test)
outTrain = np.array(wisard.classify(ds_train))
outTest = np.array(wisard.classify(ds_test))
print('Train accuracy:', accuracy_score(outTrain, [labels[ix] for ix in train_index]))
print('Test accuracy:', accuracy_score(outTest, [labels[ix] for ix in test_index]))
svm = SVC()
svm.fit(dbmatrix[train_index], [labels[ix] for ix in train_index])
