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)