def run(self, X_train, X_test, y_train, classes):
wsd = wp.Wisard(self.addr_size)
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)
wsd.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(wp.BinInput(x))
y_pred_ps.append(wsd.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 __init__(self, mapping):
_mapping = {}
for i in range(len(mapping)):
_mapping[str(i)] = mapping[i]
self.ptr = wp.Wisard(len(mapping[0][0]), mapping=_mapping)
def _calculate_score(self, ds, tuple_size):
with Timer(factor=self.factor) as creation:
mapping = {}
for label, choice_priorities in self.priorities.items():
mapping[str(label)] = create_mapping_by_restrictions(
self.restrictions[label],
choice_priorities_to_priority_of_choice(choice_priorities),
tuple_size,
ds.entry_size,
)
wsd = wp.Wisard(tuple_size, mapping=mapping)
with Timer(factor=self.factor) as training:
wsd.train(ds.train)
with Timer(factor=self.factor) as classification:
score = wsd.score(ds.test)
return {
"n": tuple_size,
"accuracy": score,
"creation_time": creation.elapsed,
"training_time": training.elapsed,
"classification_time": classification.elapsed,
}
def run(self, X_train, X_test, y_train, classes):
wsds = {}
for label in classes:
wsds[label] = wp.Wisard(self.addr_size)
start_time = time.time()
for i in range(len(X_train)):
if label in y_train[i]:
ds = wp.DataSet()
ds.add(wp.BinInput(X_train[i]), "true")
wsds[label].train(ds)
else:
ds = wp.DataSet()
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)
for label in classes:
ds_test = wp.DataSet()
for i in range(len(X_test)):
ds_test.add(wp.BinInput(X_test[i]))
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(self):
try:
wsd = wp.Wisard(3)
wsd.train(self.X, self.y)
out = wsd.classify(self.X)
self.assertSequenceEqual(self.y, out)
except RuntimeError and TypeError:
self.fail("classify 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_json(self):
try:
wsd = wp.Wisard(3)
wsd.train(self.X, self.y)
ojsonout = wsd.json()
import sys
if sys.version_info[0] < 3:
self.assertIsInstance(ojsonout, unicode)
else:
self.assertIsInstance(ojsonout, str)
jsonout = json.loads(ojsonout)
self.assertIsInstance(jsonout, dict)
wsd2 = wp.Wisard(ojsonout)
self.assertSequenceEqual(wsd.classify(self.X),
wsd2.classify(self.X))
except RuntimeError and TypeError:
self.fail("json test fail")
def test_mental_image(self):
try:
wsd = wp.Wisard(3)
X = [[1, 1, 1, 1, 1, 0, 0, 0, 0], [1, 1, 1, 1, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 1, 1, 1, 1, 1], [0, 0, 0, 0, 0, 1, 1, 1, 1]]
y = ["cold", "cold", "hot", "hot"]
wsd.train(X, y)
m = [[2, 2, 2, 2, 1, 0, 0, 0, 0], [0, 0, 0, 0, 1, 2, 2, 2, 2]]
im = wsd.getMentalImages()
self.assertSequenceEqual(m[0], im["cold"])
self.assertSequenceEqual(m[1], im["hot"])
except RuntimeError and TypeError:
self.fail("mental image test fail")
def test_sizeof(self):
try:
wsd = wp.Wisard(20)
X = []
y = []
from random import randint as ri
for i in range(300):
l = [ri(0, 1) if j < 51 else 0 for j in range(100)]
X.append(l)
y.append("cold")
for i in range(300):
l = [ri(0, 1) if j > 50 else 0 for j in range(100)]
X.append(l)
y.append("hot")
wsd.train(X, y)
self.assertLess(wsd.getsizeof(), len(wsd.json()))
except RuntimeError and TypeError:
self.fail("sizeof test fail")
def _calculate_score(self, ds, tuple_size):
with Timer(factor=self.factor) as creation:
mapping = {}
for label, img in self._metric_images.items():
mapping[str(label)] = np.reshape(argsort(img),
(-1, tuple_size))
wsd = wp.Wisard(tuple_size, mapping=mapping)
with Timer(factor=self.factor) as training:
wsd.train(ds.train)
with Timer(factor=self.factor) as classification:
score = wsd.score(ds.test)
return {
"n": tuple_size,
"accuracy": score,
"creation_time": creation.elapsed,
"training_time": training.elapsed,
"classification_time": classification.elapsed,
}
def test_train(self):
try:
wsd = wp.Wisard(3)
wsd.train(self.X, self.y)
except RuntimeError and TypeError:
self.fail("train test fail")
kf = KFold(n_splits=nsplits) # modelo kf
k = 1
for tr_idx, te_idx in kf.split(X):
print("Fold {0:1d}:".format(k))
X_tr = X[tr_idx]
X_te = X[te_idx]
Y_tr = Y[tr_idx]
Y_te = Y[te_idx]
# Criação do modelo
wsd = wp.Wisard(addressSize,
bleachingActivated=bleachingActivated,
ignoreZero=ignoreZero,
completeAddressing=completeAddressing,
verbose=verbose,
returnActivationDegree=returnActivationDegree,
returnConfidence=returnConfidence,
returnClassesDegrees=returnClassesDegrees)
# Treinamento
startTime = time.time()
wsd.train(X_tr, Y_tr)
endTime = time.time()
T_tr_n = endTime - startTime
print("\tTreinamento concluído em {0:1.2f}s".format(T_tr_n))
T_tr = np.append(T_tr, T_tr_n)
# Classificação
startTime = time.time()
G = wsd.classify(X_te)
def cross_validate_wisard(tuple_sizes, number_of_folds, training_sample, sample_targets):
chunk_size = int(len(training_sample) / number_of_folds)
#print("Chunk size: " + str(chunk_size) + "\n")
#print("Control point 10.1")
#print(process.memory_info()[0])
training_sample_chunks = [training_sample[x:x+chunk_size] for x in range(0, len(training_sample), chunk_size)]
target_chunks = [sample_targets[x:x+chunk_size] for x in range(0, len(sample_targets), chunk_size)]
#print("Control point 10.2")
#print(process.memory_info()[0])
scores_dict = {}
for tuple_size in tuple_sizes:
scores = {
"accuracy_scores": [],
"f1_scores": [],
"precisions": [],
"recalls": [],
"total_correct": [],
"true_positives": [],
"true_negatives": [],
"false_positives": [],
"false_negatives": [],
}
for fold in range(number_of_folds):
#print("Running fold " + str(fold) + ".")
fold_training_sample = []
fold_training_targets = []
#print("Control point 10.3")
#print(process.memory_info()[0])
for i in range(len(training_sample_chunks)):
if i == fold:
continue
#print("Control point 10.3.1")
#print(process.memory_info()[0])
fold_training_sample = fold_training_sample + training_sample_chunks[i]
fold_training_targets = fold_training_targets + target_chunks[i]
#print("Control point 10.4")
#print(process.memory_info()[0])
#wisard = Wisard(tupple_size = tuple_size, seed = 3356, bleaching = True)
#wisard.fit(fold_training_sample, fold_training_targets)
wann = wp.Wisard(tuple_size, bleachingActivated=True, ignoreZero=False)
#print("Control point 10.4.1")
#print(process.memory_info()[0])
wann.train(fold_training_sample, fold_training_targets)
#print("Trained.")
#print("Control point 10.5")
#print(process.memory_info()[0])
#score = wisard.score(training_sample_chunks[fold], target_chunks[fold])
scores_and_other_data = calculate_score(wann.classify(training_sample_chunks[fold]), target_chunks[fold])
scores["accuracy_scores"].append(scores_and_other_data["accuracy"])
scores["f1_scores"].append(scores_and_other_data["f1_score"])
scores["precisions"].append(scores_and_other_data["precision"])
scores["recalls"].append(scores_and_other_data["recall"])
scores["total_correct"].append(scores_and_other_data["total_correct"])
scores["true_positives"].append(scores_and_other_data["true_positives"])
scores["true_negatives"].append(scores_and_other_data["true_negatives"])
scores["false_positives"].append(scores_and_other_data["false_positives"])
scores["false_negatives"].append(scores_and_other_data["false_negatives"])
print(tuple_size, "Scores: " + str(scores_and_other_data["accuracy"]) + " " + str(scores_and_other_data["f1_score"]) + ".\n")
#print("Control point 10.6")
#print(process.memory_info()[0])
del wann
scores_dict[tuple_size] = scores
return scores_dict
def test_build(self):
try:
wsd = wp.Wisard(3)
self.assertIsInstance(wsd, wp.Wisard)
except TypeError:
self.fail("Wisard instantiation failed!")
def random_wisard(self):
return wp.Wisard(np.random.randint(LOW_N, HIGH_N))
for out2 in output2:
erro_benchmarck = []
erro_proposal_3 = []
erro_proposal_5 = []
erro_proposal_10 = []
df_last2 = df_last[df_last['output_most'] == out2]
if df_last2['output_most'].shape[0] >100:
df_last2['random'] = [random() for x in range(len(df_last2))]
df_last2 = df_last2.sort_values('random')
X = [list(map(lambda y: int(y), x)) for x in list(df_last2['total'])]
y = list(df_last2['output_rating'])
train_X = X[:t]
train_y = y[:t]
classify_X = X[-100:]
classify_y = y[-100:]
wsd = wp.Wisard(addressSize, ignoreZero=ignoreZero, verbose=verbose)
wsd.train(train_X,train_y)
out = wsd.classify(classify_X)
erro = 0
for i,d in enumerate(classify_X):
a,b = denota(out[i]),denota(classify_y[i])
erro += (a-b)**2
erro_benchmarck.append(np.average(erro)**0.5)
X2 = [reduz(x,3) for x in X]
train_X2 = X2[:t]
classify_X2 = X2[t:t+100]
wsd = wp.Wisard(addressSize, ignoreZero=ignoreZero, verbose=verbose)
wsd.train(train_X2,train_y)
out = wsd.classify(classify_X2)
Xaux3[idx1]
): # percorrer elementos e respetivos indices contidos na sublista, aqui enumerate(i) tambem daria
if (j <= 125 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
print("Número de folds: ", n_folds)
print("Address Size: ", address)
kfold = KFold(n_folds, shuffle=True)
wsd = wp.Wisard(address, ignoreZero=False, verbose=False)
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")
wsd.train(trainX, trainY)
print("treinou")
out = wsd.classify(testX)
print("classificou")
# acertos=0
# for i, d in enumerate(testY):
# if(out[i] == testY[i]):
import wisardpkg ws = wisardpkg.Wisard(4) ws.train([[0, 0, 1, 1], [0, 1, 1, 1]], ["blue", "dark"]) out = ws.classify([[1, 1, 1, 1]]) print(out)
