def main(): nn = NN() epoch = 50 x, y = DataUtil.get_dataset("cifar10", "../_Data/cifar10.txt", quantized=True, one_hot=True) x = x.reshape(len(x), 3, 32, 32) nn.add("ConvReLU", (x.shape[1:], (32, 3, 3))) nn.add("ConvReLU", ((32, 3, 3),)) nn.add("MaxPool", ((3, 3),), 2) nn.add("ConvNorm") nn.add("ConvDrop") nn.add("ConvReLU", ((64, 3, 3),)) nn.add("ConvReLU", ((64, 3, 3),)) nn.add("AvgPool", ((3, 3),), 2) nn.add("ConvNorm") nn.add("ConvDrop") nn.add("ConvReLU", ((32, 3, 3),)) nn.add("ConvReLU", ((32, 3, 3),)) nn.add("AvgPool", ((3, 3),), 2) nn.add("ReLU", (512,)) nn.add("Identical", (64,), apply_bias=False) nn.add("Normalize", activation="ReLU") nn.add("Dropout") nn.add("CrossEntropy", (y.shape[1],)) # nn.disable_timing() nn.fit(x, y, lr=0.001, epoch=epoch, train_rate=0.8, metrics=["acc"], record_period=1, verbose=4) nn.evaluate(x, y) nn.show_timing_log() nn.draw_logs()
def main(): nn = NNDist() save = False load = False show_loss = True train_only = False verbose = 2 lr = 0.001 lb = 0.001 epoch = 5 record_period = 1 x, y = DataUtil.get_dataset("mnist", "../../../../_Data/mnist.txt", quantized=True, one_hot=True) batch_size = 128 if not load: nn.add("ReLU", (x.shape[1], 1024)) nn.add("ReLU", (1024,)) nn.add("CrossEntropy", (y.shape[1],)) nn.optimizer = "Adam" nn.preview() nn.fit(x, y, lr=lr, lb=lb, epoch=epoch, batch_size=batch_size, record_period=record_period, show_loss=show_loss, train_only=train_only, do_log=True, verbose=verbose) if save: nn.save() nn.draw_results() else: nn.load() nn.preview() print(nn.evaluate(x, y)[0]) nn.show_timing_log()
def __init__(self, im=None, om=None): self._im, self._om = im, om self._cursor = self._indices = None self._x, self._y = DataUtil.get_dataset("mnist", "../../_Data/mnist.txt", quantized=True, one_hot=True) self._x = self._x.reshape(-1, 28, 28) self._x_train, self._x_test = self._x[:1800], self._x[1800:] self._y_train, self._y_test = self._y[:1800], self._y[1800:]
def main(): x, y = DataUtil.get_dataset("mnist", "../../../_Data/mnist.txt", quantized=True, one_hot=True) x = x.reshape(len(x), 1, 28, 28) nn = NNDist() # nn.add("ReLU", (x.shape[1], 24)) # nn.add("ReLU", (24, )) # nn.add("CrossEntropy", (y.shape[1], )) nn.add("ConvReLU", (x.shape[1:], (32, 3, 3))) nn.add("ConvReLU", ((32, 3, 3),)) nn.add("MaxPool", ((3, 3),), 2) nn.add("ConvNorm") nn.add("ConvDrop") nn.add("ConvReLU", ((64, 3, 3),), std=0.01) nn.add("ConvReLU", ((64, 3, 3),), std=0.01) nn.add("AvgPool", ((3, 3),), 2) nn.add("ConvNorm") nn.add("ConvDrop") nn.add("ConvReLU", ((32, 3, 3),)) nn.add("ConvReLU", ((32, 3, 3),)) nn.add("AvgPool", ((3, 3),), 2) nn.add("ReLU", (512,)) nn.add("Identical", (64,)) nn.add("Normalize", activation="ReLU") nn.add("Dropout") nn.add("CrossEntropy", (y.shape[1],)) nn.optimizer = "Adam" nn.preview() nn.fit(x, y, verbose=2, do_log=True) nn.evaluate(x, y) nn.draw_results() nn.show_timing_log()
def main(): nn = NNDist() verbose = 2 lr = 0.001 epoch = 50 record_period = 5 timing = Timing(enabled=True) timing_level = 1 nn.feed_timing(timing) x, y = DataUtil.get_dataset("mnist", "../../_Data/mnist.txt", quantized=True, one_hot=True) nn.add(ReLU((x.shape[1], 400))) nn.add(CrossEntropy((y.shape[1], ))) nn.fit(x, y, lr=lr, epoch=epoch, record_period=record_period, verbose=verbose, train_rate=0.8) nn.draw_logs() timing.show_timing_log(timing_level)
def __init__(self, im=None, om=None, one_hot=True): super(MnistGenerator, self).__init__(im, om) self._x, self._y = DataUtil.get_dataset("mnist", "../_Data/mnist.txt", quantized=True, one_hot=one_hot) self._x = self._x.reshape(-1, 28, 28) self._x_train, self._x_test = self._x[:1800], self._x[1800:] self._y_train, self._y_test = self._y[:1800], self._y[1800:]
def main(): nn = NNDist() save = False load = False show_loss = True train_only = False visualize = False verbose = 2 lr = 0.001 lb = 0.001 epoch = 10 record_period = 1 timing = Timing(enabled=True) timing_level = 1 x, y = DataUtil.get_dataset("mnist", "../../_Data/mnist.txt", quantized=True, one_hot=True) x = x.reshape(len(x), 1, 28, 28) if not load: nn.add("ConvReLU", (x.shape[1:], (32, 3, 3))) nn.add("ConvReLU", ((32, 3, 3),)) nn.add("MaxPool", ((3, 3),), 1) nn.add("ConvNorm") nn.add("ConvDrop") nn.add("ConvReLU", ((64, 3, 3),)) nn.add("ConvReLU", ((64, 3, 3),)) nn.add("MaxPool", ((3, 3),), 1) nn.add("ConvNorm") nn.add("ConvDrop") nn.add("ConvReLU", ((32, 3, 3),)) nn.add("ConvReLU", ((32, 3, 3),)) nn.add("MaxPool", ((3, 3),), 1) nn.add("ReLU", (512,)) nn.add("Identical", (64,)) nn.add("Normalize") nn.add("Dropout") nn.add("CrossEntropy", (y.shape[1],)) nn.optimizer = "Adam" nn.preview() nn.feed_timing(timing) nn.fit(x, y, lr=lr, lb=lb, epoch=epoch, batch_size=32, record_period=record_period, show_loss=show_loss, train_only=train_only, do_log=True, verbose=verbose, visualize=visualize) if save: nn.save() nn.draw_results() else: nn.load() nn.preview() nn.evaluate(x, y) timing.show_timing_log(timing_level)
def main(): save = False load = False show_loss = True train_only = False verbose = 2 lr = 0.001 lb = 0.001 epoch = 10 record_period = 1 x, y = DataUtil.get_dataset("mnist", "../../../_Data/mnist.txt", quantized=True, one_hot=True) x = x.reshape(len(x), 1, 28, 28) if not load: nn = NNDist() # nn.add("ReLU", (x.shape[1], 24)) # nn.add("ReLU", (24, )) # nn.add("CrossEntropy", (y.shape[1], )) nn.add("ConvReLU", (x.shape[1:], (32, 3, 3))) nn.add("ConvReLU", ((32, 3, 3),)) nn.add("MaxPool", ((3, 3),), 2) nn.add("ConvNorm") nn.add("ConvDrop") nn.add("ConvReLU", ((64, 3, 3),), std=0.01) nn.add("ConvReLU", ((64, 3, 3),), std=0.01) nn.add("AvgPool", ((3, 3),), 2) nn.add("ConvNorm") nn.add("ConvDrop") nn.add("ConvReLU", ((32, 3, 3),)) nn.add("ConvReLU", ((32, 3, 3),)) nn.add("AvgPool", ((3, 3),), 2) nn.add("ReLU", (512,)) nn.add("Identical", (64,)) nn.add("Normalize", activation="ReLU") nn.add("Dropout") nn.add("CrossEntropy", (y.shape[1],)) nn.optimizer = "Adam" nn.preview(verbose=verbose) nn.fit(x, y, lr=lr, lb=lb, epoch=epoch, batch_size=256, record_period=record_period, show_loss=show_loss, train_only=train_only, do_log=True, tensorboard_verbose=1, verbose=verbose) if save: nn.save() else: nn = NNFrozen() nn.load() nn.preview() nn.evaluate(x, y) nn.show_timing_log()
def main(): # # x, y = DataUtil.gen_xor(100, one_hot=False) # x, y = DataUtil.gen_spin(20, 4, 2, 2, one_hot=False) # # x, y = DataUtil.gen_two_clusters(n_dim=2, one_hot=False) # y[y == 0] = -1 # # svm = SKSVM() # # svm = SKSVM(kernel="poly", degree=12) # svm.fit(x, y) # svm.estimate(x, y) # svm.visualize2d(x, y, padding=0.1, dense=400, emphasize=svm.support_) # # svm = SVM() # _logs = [_log[0] for _log in svm.fit(x, y, metrics=["acc"])] # svm.estimate(x, y) # svm.visualize2d(x, y, padding=0.1, dense=400, emphasize=svm["alpha"] > 0) (x_train, y_train), (x_test, y_test), *_ = DataUtil.get_dataset("mushroom", "../_Data/mushroom.txt", train_num=100, quantize=True, tar_idx=0) y_train[y_train == 0] = -1 y_test[y_test == 0] = -1 svm = SKSVM() svm.fit(x_train, y_train) svm.estimate(x_train, y_train) svm.estimate(x_test, y_test) svm = SVM() _logs = [ _log[0] for _log in svm.fit( x_train, y_train, metrics=["acc"], x_test=x_test, y_test=y_test) ] # svm.fit(x_train, y_train, p=12) svm.estimate(x_train, y_train) svm.estimate(x_test, y_test) plt.figure() plt.title(svm.title) plt.plot(range(len(_logs)), _logs) plt.show() svm.show_timing_log()
def main(): nn = NN() epoch = 10 x, y = DataUtil.get_dataset("mnist", "../Data/mnist.txt", quantized=True, one_hot=True) nn.add("ReLU", (x.shape[1], 24)) nn.add("ReLU", (24, )) nn.add("CrossEntropy", (y.shape[1], )) nn.fit(x, y, lr=0.001, epoch=epoch, train_rate=0.8, metrics=["acc"], record_period=1, verbose=2)
def main(): nn = NNDist() verbose = 2 lr = 0.001 epoch = 50 record_period = 5 timing = Timing(enabled=True) timing_level = 1 nn.feed_timing(timing) x, y = DataUtil.get_dataset("cifar10", "../../_Data/cifar10.txt", quantized=True, one_hot=True) x = x.reshape(len(x), 3, 32, 32) nn.add(ConvReLU((x.shape[1:], (32, 3, 3)))) nn.add(ConvReLU(((32, 3, 3), ))) nn.add(MaxPool(((3, 3), ), 2)) nn.add(ConvReLU(((64, 3, 3), ))) nn.add(ConvReLU(((64, 3, 3), ))) nn.add(AvgPool(((3, 3), ), 2)) nn.add(ConvReLU(((32, 3, 3), ))) nn.add(ConvReLU(((32, 3, 3), ))) nn.add(AvgPool(((3, 3), ), 2)) nn.add(ReLU((512, ))) nn.add(ReLU((64, ))) nn.add(CrossEntropy((y.shape[1], ))) nn.fit(x, y, lr=lr, epoch=epoch, record_period=record_period, verbose=verbose, train_rate=0.8) nn.draw_logs() timing.show_timing_log(timing_level)
def main(): timing = Timing(enabled=True) timing_level = 1 x, y = DataUtil.get_dataset("mnist", "../../_Data/mnist.txt", quantized=True, one_hot=True) x = x.reshape(len(x), 1, 28, 28) nn = NNDist() # nn.add("ReLU", (x.shape[1], 24)) # nn.add("ReLU", (24, )) # nn.add("CrossEntropy", (y.shape[1], )) nn.add("ConvReLU", (x.shape[1:], (32, 3, 3))) nn.add("ConvReLU", ((32, 3, 3), )) nn.add("MaxPool", ((3, 3), ), 2) nn.add("ConvNorm") nn.add("ConvDrop") nn.add("ConvReLU", ((64, 3, 3), ), std=0.01) nn.add("ConvReLU", ((64, 3, 3), ), std=0.01) nn.add("AvgPool", ((3, 3), ), 2) nn.add("ConvNorm") nn.add("ConvDrop") nn.add("ConvReLU", ((32, 3, 3), )) nn.add("ConvReLU", ((32, 3, 3), )) nn.add("AvgPool", ((3, 3), ), 2) nn.add("ReLU", (512, )) nn.add("Identical", (64, )) nn.add("Normalize", activation="ReLU") nn.add("Dropout") nn.add("CrossEntropy", (y.shape[1], )) nn.optimizer = "Adam" nn.preview() nn.fit(x, y, verbose=2, do_log=True, show_loss=True) nn.draw_results() timing.show_timing_log(timing_level)
def main(): # _x, _y = DataUtil.get_dataset("balloon1.0(en)", "../_Data/balloon1.0(en).txt") _x, _y = DataUtil.get_dataset("test", "../_Data/test.txt") _fit_time = time.time() _tree = CartTree(whether_continuous=[False] * 4) _tree.fit(_x, _y, train_only=True) _fit_time = time.time() - _fit_time _tree.view() _estimate_time = time.time() _tree.estimate(_x, _y) _estimate_time = time.time() - _estimate_time print( "Model building : {:12.6} s\n" "Estimation : {:12.6} s\n" "Total : {:12.6} s".format( _fit_time, _estimate_time, _fit_time + _estimate_time ) ) _tree.visualize() train_num = 6000 (x_train, y_train), (x_test, y_test), *_ = DataUtil.get_dataset( "mushroom", "../_Data/mushroom.txt", tar_idx=0, train_num=train_num) _fit_time = time.time() _tree = C45Tree() _tree.fit(x_train, y_train) _fit_time = time.time() - _fit_time _tree.view() _estimate_time = time.time() _tree.estimate(x_train, y_train) _tree.estimate(x_test, y_test) _estimate_time = time.time() - _estimate_time print( "Model building : {:12.6} s\n" "Estimation : {:12.6} s\n" "Total : {:12.6} s".format( _fit_time, _estimate_time, _fit_time + _estimate_time ) ) _tree.visualize() _x, _y = DataUtil.gen_xor(one_hot=False) _fit_time = time.time() _tree = CartTree() _tree.fit(_x, _y, train_only=True) _fit_time = time.time() - _fit_time _tree.view() _estimate_time = time.time() _tree.estimate(_x, _y) _estimate_time = time.time() - _estimate_time print( "Model building : {:12.6} s\n" "Estimation : {:12.6} s\n" "Total : {:12.6} s".format( _fit_time, _estimate_time, _fit_time + _estimate_time ) ) _tree.visualize2d(_x, _y) _tree.visualize() _wc = [False] * 16 _continuous_lst = [0, 5, 9, 11, 12, 13, 14] for _cl in _continuous_lst: _wc[_cl] = True train_num = 2000 (x_train, y_train), (x_test, y_test), *_ = DataUtil.get_dataset( "bank1.0", "../_Data/bank1.0.txt", train_num=train_num, quantize=True) _fit_time = time.time() _tree = CartTree() _tree.fit(x_train, y_train) _fit_time = time.time() - _fit_time _tree.view() _estimate_time = time.time() _tree.estimate(x_test, y_test) _estimate_time = time.time() - _estimate_time print( "Model building : {:12.6} s\n" "Estimation : {:12.6} s\n" "Total : {:12.6} s".format( _fit_time, _estimate_time, _fit_time + _estimate_time ) ) _tree.visualize() _tree.show_timing_log()
def main(): # x, y = DataUtil.gen_xor(100, one_hot=False) x, y = DataUtil.gen_spiral(20, 4, 2, 2, one_hot=False) # x, y = DataUtil.gen_two_clusters(n_dim=2, one_hot=False) y[y == 0] = -1 animation_params = { "show": False, "mp4": False, "period": 50, "dense": 400, "draw_background": True } svm = SVM(animation_params=animation_params) svm.fit(x, y, kernel="poly", p=12, epoch=600) svm.evaluate(x, y) svm.visualize2d(x, y, padding=0.1, dense=400, emphasize=svm["alpha"] > 0) svm = GDSVM(animation_params=animation_params) svm.fit(x, y, kernel="poly", p=12, epoch=10000) svm.evaluate(x, y) svm.visualize2d(x, y, padding=0.1, dense=400, emphasize=svm["alpha"] > 0) if TorchSVM is not None: svm = TorchSVM(animation_params=animation_params) svm.fit(x, y, kernel="poly", p=12) svm.evaluate(x, y) svm.visualize2d(x, y, padding=0.1, dense=400, emphasize=svm["alpha"] > 0) svm = TFSVM() svm.fit(x, y) svm.evaluate(x, y) svm.visualize2d(x, y, padding=0.1, dense=400) svm = SKSVM() # svm = SKSVM(kernel="poly", degree=12) svm.fit(x, y) svm.evaluate(x, y) svm.visualize2d(x, y, padding=0.1, dense=400, emphasize=svm.support_) (x_train, y_train), (x_test, y_test), *_ = DataUtil.get_dataset( "mushroom", "../_Data/mushroom.txt", n_train=100, quantize=True, tar_idx=0) y_train[y_train == 0] = -1 y_test[y_test == 0] = -1 svm = SKSVM() svm.fit(x_train, y_train) svm.evaluate(x_train, y_train) svm.evaluate(x_test, y_test) svm = TFSVM() svm.fit(x_train, y_train) svm.evaluate(x_train, y_train) svm.evaluate(x_test, y_test) if TorchSVM is not None: svm = TorchSVM() svm.fit(x_train, y_train) svm.evaluate(x_train, y_train) svm.evaluate(x_test, y_test) svm = TorchSVM() logs = [log[0] for log in svm.fit( x_train, y_train, metrics=["acc"], x_test=x_test, y_test=y_test )] svm.evaluate(x_train, y_train) svm.evaluate(x_test, y_test) plt.figure() plt.title(svm.title) plt.plot(range(len(logs)), logs) plt.show() svm = SVM() logs = [log[0] for log in svm.fit( x_train, y_train, metrics=["acc"], x_test=x_test, y_test=y_test )] svm.evaluate(x_train, y_train) svm.evaluate(x_test, y_test) plt.figure() plt.title(svm.title) plt.plot(range(len(logs)), logs) plt.show() svm = GDSVM() logs = [log[0] for log in svm.fit( x_train, y_train, metrics=["acc"], x_test=x_test, y_test=y_test )] svm.evaluate(x_train, y_train) svm.evaluate(x_test, y_test) plt.figure() plt.title(svm.title) plt.plot(range(len(logs)), logs) plt.show() svm.show_timing_log()
if discrete: idx += 1 return x if __name__ == '__main__': import time whether_continuous = [False] * 16 continuous_lst = [0, 5, 9, 11, 12, 13, 14] for cl in continuous_lst: whether_continuous[cl] = True train_num = 40000 data_time = time.time() (x_train, y_train), (x_test, y_test) = DataUtil.get_dataset( "bank1.0", "../../_Data/bank1.0.txt", n_train=train_num) data_time = time.time() - data_time learning_time = time.time() nb = MergedNB(whether_continuous=whether_continuous) nb.fit(x_train, y_train) learning_time = time.time() - learning_time estimation_time = time.time() nb.evaluate(x_train, y_train) nb.evaluate(x_test, y_test) estimation_time = time.time() - estimation_time print( "Data cleaning : {:12.6} s\n" "Model building : {:12.6} s\n"
def main(): log = "" nn = NNDist() save = False load = False show_loss = True train_only = False visualize = False verbose = 2 lr = 0.001 lb = 0.001 epoch = 50 record_period = 1 timing = Timing(enabled=True) timing_level = 1 x, y = DataUtil.get_dataset("cifar10", "../../_Data/cifar10.txt", quantized=True, one_hot=True) x = x.reshape(len(x), 3, 32, 32) if not load: def add_layers(_nn): _nn.add("Pipe", 3) _nn.add_pipe_layer(0, "ConvReLU", ((32, 1, 3), )) _nn.add_pipe_layer(0, "ConvReLU", ((32, 3, 1), )) _nn.add_pipe_layer(1, "ConvReLU", ((32, 2, 3), )) _nn.add_pipe_layer(1, "ConvReLU", ((32, 3, 2), )) _nn.add_pipe_layer(2, "ConvReLU", ((32, 1, 1), )) _nn.add_pipe_layer(2, "Pipe", 2) _pipe = _nn.get_current_pipe(2) _pipe.add_pipe_layer(0, "ConvReLU", ((16, 1, 3), )) _pipe.add_pipe_layer(1, "ConvReLU", ((16, 3, 1), )) nn.add("ConvReLU", (x.shape[1:], (32, 3, 3))) nn.add("ConvReLU", ((32, 3, 3), )) nn.add("MaxPool", ((3, 3), ), 2) nn.add("ConvNorm") add_layers(nn) nn.add("MaxPool", ((3, 3), ), 2) nn.add("ConvNorm") add_layers(nn) nn.add("AvgPool", ((3, 3), ), 2) nn.add("ConvNorm") add_layers(nn) nn.add("ReLU", (512, )) nn.add("ReLU", (64, )) nn.add("Normalize") nn.add("CrossEntropy", (y.shape[1], )) nn.optimizer = "Adam" nn.preview() nn.feed_timing(timing) nn.fit(x, y, lr=lr, lb=lb, epoch=epoch, batch_size=256, record_period=record_period, show_loss=show_loss, train_only=train_only, do_log=True, verbose=verbose, visualize=visualize) if save: nn.save() nn.draw_conv_series(x[:3], (3, 32, 32)) nn.draw_results() else: nn.load("Models/Model") nn.feed(x, y) nn.preview() nn.fit(epoch=5, lr=lr, lb=lb, verbose=verbose) if visualize: nn.visualize2d() nn.draw_results() acc = nn.evaluate(x, y)[0] log += "Whole set Accuracy : {:12.6} %".format(100 * acc) + "\n" print() print("=" * 30 + "\n" + "Results\n" + "-" * 30) print(log) timing.show_timing_log(timing_level)
print("=" * 30) print("Testing {} ({})...".format(algorithm, clf)) print('_' * 30) t = time.time() ensemble = clf_dict[algorithm]() ensemble.fit(x, y, None, clf, ensemble, **kwargs) ensemble.evaluate(xt, yt) print("Time cost:{:8.6} s".format(time.time() - t)) if __name__ == '__main': _x, _y = DataUtil.gen_spiral(size=20, n = 4, n_class=2, one_hot=False) _y[_y == 0] = -1 test(_x, _y, algorithm="RF", epoch=30, n_cores = 4) test(_x, _y, algorithm="SKAdaBoost") train_num = 6000 (x_train, y_train), (x_test, y_test), *_ = DataUtil.get_dataset( "mushroom", "/Users/lily/Documents/MachineLearning-master/_Data/mushroom.txt", train_num=train_num, quantize=True, tar_idx=0 ) y_train[y_train == 0] = -1 y_test[y_test == 0] = -1 cv_test(x_train, y_train, x_test, y_test, clf = "MNB", epoch=1) cv_test(x_train, y_train, x_test, y_test, clf = "MNB", epoch=5) cv_test(x_train, y_train, x_test, y_test, clf = "MNB", epoch=10) cv_test(x_train, y_train, x_test, y_test, clf = "MNB", epoch=15) AdaBoost.show_timing_log()
plt.bar(tmp_x - 0.35 * c, self._data[j][c, :], width=0.35, facecolor=colors[self.label_dict[c]], edgecolor="white", label=u"class: {}".format(self.label_dict[c])) plt.xticks([i for i in range(sj + 2)], [""] + [rev_dict[i] for i in range(sj)] + [""]) plt.ylim(0, 1.0) plt.legend() if not save: plt.show() else: plt.savefig("d{}".format(j + 1)) if __name__ == '__main__': import time train_num = 6000 (x_train, y_train), (x_test, y_test) = DataUtil.get_dataset( "mushroom", "../../_Data/mushroom.txt", n_train=train_num, tar_idx=0) learning_time = time.time() nb = MultinomialNB() nb.fit(x_train, y_train) learning_time = time.time() - learning_time estimation_time = time.time() nb.evaluate(x_train, y_train) nb.evaluate(x_test, y_test) estimation_time = time.time() - estimation_time print( "Model building : {:12.6} s\n" "Estimation : {:12.6} s\n" "Total : {:12.6} s".format( learning_time, estimation_time, learning_time + estimation_time
def main(visualize=True): # x, y = DataUtil.get_dataset("balloon1.0(en)", "../_Data/balloon1.0(en).txt") x, y = DataUtil.get_dataset( "test", "/Users/lily/Documents/MachineLearning-master/_Data/test.txt") fit_time = time.time() tree = CartTree(whether_continuous=[False] * 4) tree.fit(x, y, train_only=True) fit_time = time.time() - fit_time if visualize: tree.view() estimate_time = time.time() tree.evaluate(x, y) estimate_time = time.time() - estimate_time print("Model building : {:12.6} s\n" "Estimation : {:12.6} s\n" "Total : {:12.6} s".format(fit_time, estimate_time, fit_time + estimate_time)) if visualize: tree.visualize() train_num = 6000 (x_train, y_train), (x_test, y_test), *_ = DataUtil.get_dataset( "mushroom", "/Users/lily/Documents/MachineLearning-master/_Data/mushroom.txt", tar_idx=0, train_num=train_num) fit_time = time.time() tree = C45Tree() tree.fit(x_train, y_train) fit_time = time.time() - fit_time if visualize: tree.view() estimate_time = time.time() tree.evaluate(x_train, y_train) tree.evaluate(x_test, y_test) estimate_time = time.time() - estimate_time print("Model building : {:12.6} s\n" "Estimation : {:12.6} s\n" "Total : {:12.6} s".format(fit_time, estimate_time, fit_time + estimate_time)) if visualize: tree.visualize() x, y = DataUtil.gen_xor(one_hot=False) fit_time = time.time() tree = CartTree() tree.fit(x, y, train_only=True) fit_time = time.time() - fit_time if visualize: tree.view() estimate_time = time.time() tree.evaluate(x, y, n_cores=1) estimate_time = time.time() - estimate_time print("Model building : {:12.6} s\n" "Estimation : {:12.6} s\n" "Total : {:12.6} s".format(fit_time, estimate_time, fit_time + estimate_time)) if visualize: tree.visualize2d(x, y, dense=1000) tree.visualize() wc = [False] * 16 continuous_lst = [0, 5, 9, 11, 12, 13, 14] for _cl in continuous_lst: wc[_cl] = True train_num = 2000 (x_train, y_train), (x_test, y_test), *_ = DataUtil.get_dataset( "bank1.0", "/Users/lily/Documents/MachineLearning-master/_Data/bank1.0.txt", train_num=train_num, quantize=True) fit_time = time.time() tree = CartTree() tree.fit(x_train, y_train) fit_time = time.time() - fit_time if visualize: tree.view() estimate_time = time.time() tree.evaluate(x_test, y_test) estimate_time = time.time() - estimate_time print("Model building : {:12.6} s\n" "Estimation : {:12.6} s\n" "Total : {:12.6} s".format(fit_time, estimate_time, fit_time + estimate_time)) if visualize: tree.visualize() tree.show_timing_log()
w3[leaf_id_cursor] = rs / np.sum(rs) leaf_id_cursor += 1 w2 *= max_route_length self._transform_ws = [w1, w2, w3] self._transform_bs = [b] if __name__ == '__main__': from Util.Util import DataUtil centers = (1, 1) slopes = (0.5, -2) x, y = DataUtil.gen_x_set(1000, centers, slopes, one_hot=False) x_test, y_test = DataUtil.gen_x_set(100, centers, slopes, one_hot=False) (x, y), (x_test, y_test), *_ = DataUtil.get_dataset("cifar10", "../../../_Data/cifar10.txt", 400, quantized=True) DT2NN().fit(x, y, x_test, y_test).scatter2d(x, y, padding=0.1, title="X set").visualize2d( x, y).visualize2d(x_test, y_test, padding=1)
def _transfer_x(self, x): # 遍历元素 for j, char in enumerate(x): x[j] = self._feat_dics[j][char] return x if __name__=='__main__': # 导入 标准库,读取数据 import time from Util.Util import DataUtil # 遍历数据集 #dataset = "mushroom" for dataset in ("balloon1.0", "balloon1.5"): # 读入数据TypeError: 'NoneType' object is not subscriptable _x, _y = DataUtil.get_dataset(dataset, "../../data/{}.txt".format(dataset)) # 实例化模型,训练,记录时间 learning_time = time.time() nb = MultinomialNB() nb.fit(_x, _y) learning_time = time.time() - learning_time # 评估模型表现,记录话费时间 estimation_time = time.time() nb.evaluate(_x, _y) estimation_time = time.time() - estimation_time # 打印 print( "Model Building : {:12.6} s\n" "Estimation : {:12.6} s\n" "Total : {:12.6} s\n".format(learning_time, estimation_time, learning_time+estimation_time) )
def main(visualize=True): # x, y = DataUtil.get_dataset("balloon1.0(en)", "../_Data/balloon1.0(en).txt") x, y = DataUtil.get_dataset("test", "../_Data/test.txt") fit_time = time.time() tree = CartTree(whether_continuous=[False] * 4) tree.fit(x, y, train_only=True) fit_time = time.time() - fit_time if visualize: tree.view() estimate_time = time.time() tree.evaluate(x, y) estimate_time = time.time() - estimate_time print( "Model building : {:12.6} s\n" "Estimation : {:12.6} s\n" "Total : {:12.6} s".format( fit_time, estimate_time, fit_time + estimate_time ) ) if visualize: tree.visualize() train_num = 6000 (x_train, y_train), (x_test, y_test), *_ = DataUtil.get_dataset( "mushroom", "../_Data/mushroom.txt", tar_idx=0, n_train=train_num) fit_time = time.time() tree = C45Tree() tree.fit(x_train, y_train) fit_time = time.time() - fit_time if visualize: tree.view() estimate_time = time.time() tree.evaluate(x_train, y_train) tree.evaluate(x_test, y_test) estimate_time = time.time() - estimate_time print( "Model building : {:12.6} s\n" "Estimation : {:12.6} s\n" "Total : {:12.6} s".format( fit_time, estimate_time, fit_time + estimate_time ) ) if visualize: tree.visualize() x, y = DataUtil.gen_xor(one_hot=False) fit_time = time.time() tree = CartTree() tree.fit(x, y, train_only=True) fit_time = time.time() - fit_time if visualize: tree.view() estimate_time = time.time() tree.evaluate(x, y, n_cores=1) estimate_time = time.time() - estimate_time print( "Model building : {:12.6} s\n" "Estimation : {:12.6} s\n" "Total : {:12.6} s".format( fit_time, estimate_time, fit_time + estimate_time ) ) if visualize: tree.visualize2d(x, y, dense=1000) tree.visualize() wc = [False] * 16 continuous_lst = [0, 5, 9, 11, 12, 13, 14] for _cl in continuous_lst: wc[_cl] = True train_num = 2000 (x_train, y_train), (x_test, y_test), *_ = DataUtil.get_dataset( "bank1.0", "../_Data/bank1.0.txt", n_train=train_num, quantize=True) fit_time = time.time() tree = CartTree() tree.fit(x_train, y_train) fit_time = time.time() - fit_time if visualize: tree.view() estimate_time = time.time() tree.evaluate(x_test, y_test) estimate_time = time.time() - estimate_time print( "Model building : {:12.6} s\n" "Estimation : {:12.6} s\n" "Total : {:12.6} s".format( fit_time, estimate_time, fit_time + estimate_time ) ) if visualize: tree.visualize() tree.show_timing_log()
def main(): # x, y = DataUtil.gen_xor(100, one_hot=False) x, y = DataUtil.gen_spiral(20, 4, 2, 2, one_hot=False) # x, y = DataUtil.gen_two_clusters(n_dim=2, one_hot=False) y[y == 0] = -1 animation_params = { "show": False, "mp4": False, "period": 50, "dense": 400, "draw_background": True } svm = SVM(animation_params=animation_params) svm.fit(x, y, kernel="poly", p=12, epoch=600) svm.evaluate(x, y) svm.visualize2d(x, y, padding=0.1, dense=400, emphasize=svm["alpha"] > 0) svm = GDSVM(animation_params=animation_params) svm.fit(x, y, kernel="poly", p=12, epoch=10000) svm.evaluate(x, y) svm.visualize2d(x, y, padding=0.1, dense=400, emphasize=svm["alpha"] > 0) if TorchSVM is not None: svm = TorchSVM(animation_params=animation_params) svm.fit(x, y, kernel="poly", p=12) svm.evaluate(x, y) svm.visualize2d(x, y, padding=0.1, dense=400, emphasize=svm["alpha"] > 0) svm = TFSVM() svm.fit(x, y) svm.evaluate(x, y) svm.visualize2d(x, y, padding=0.1, dense=400) svm = SKSVM() # svm = SKSVM(kernel="poly", degree=12) svm.fit(x, y) svm.evaluate(x, y) svm.visualize2d(x, y, padding=0.1, dense=400, emphasize=svm.support_) (x_train, y_train), (x_test, y_test), *_ = DataUtil.get_dataset("mushroom", "../_Data/mushroom.txt", n_train=100, quantize=True, tar_idx=0) y_train[y_train == 0] = -1 y_test[y_test == 0] = -1 svm = SKSVM() svm.fit(x_train, y_train) svm.evaluate(x_train, y_train) svm.evaluate(x_test, y_test) svm = TFSVM() svm.fit(x_train, y_train) svm.evaluate(x_train, y_train) svm.evaluate(x_test, y_test) if TorchSVM is not None: svm = TorchSVM() svm.fit(x_train, y_train) svm.evaluate(x_train, y_train) svm.evaluate(x_test, y_test) svm = TorchSVM() logs = [ log[0] for log in svm.fit(x_train, y_train, metrics=["acc"], x_test=x_test, y_test=y_test) ] svm.evaluate(x_train, y_train) svm.evaluate(x_test, y_test) plt.figure() plt.title(svm.title) plt.plot(range(len(logs)), logs) plt.show() svm = SVM() logs = [ log[0] for log in svm.fit( x_train, y_train, metrics=["acc"], x_test=x_test, y_test=y_test) ] svm.evaluate(x_train, y_train) svm.evaluate(x_test, y_test) plt.figure() plt.title(svm.title) plt.plot(range(len(logs)), logs) plt.show() svm = GDSVM() logs = [ log[0] for log in svm.fit( x_train, y_train, metrics=["acc"], x_test=x_test, y_test=y_test) ] svm.evaluate(x_train, y_train) svm.evaluate(x_test, y_test) plt.figure() plt.title(svm.title) plt.plot(range(len(logs)), logs) plt.show() svm.show_timing_log()
label="class: {}".format(self.label_dict[c])) plt.xlim(x_min - 0.2 * gap, x_max + 0.2 * gap) plt.legend() if not save: plt.show() else: plt.savefig("d{}".format(j + 1)) if __name__ == "__main__": import time train_num = 6000 (x_train, y_train), (x_test, y_test) = DataUtil.get_dataset("mushroom", "../Data/mushroom.txt", n_train=train_num, tar_idx=0) learning_time = time.time() nb = GaussianNB() nb.fit(x_train, y_train) learning_time = time.time() - learning_time estimation_time = time.time() nb.evaluate(x_train, y_train) nb.evaluate(x_test, y_test) estimation_time = time.time() - estimation_time print("Model build : {:12.6} s\n" "Estimation : {:12.6} s\n" "Total : {:12.6} s\n".format( learning_time, estimation_time, learning_time + estimation_time))
label=u"class: {}".format(self.label_dic[c])) plt.xticks([i for i in range(sj + 2)], [""] + [_rev_dic[i] for i in range(sj)] + [""]) plt.ylim(0, 1.0) plt.legend() if not save: plt.show() else: plt.savefig("d{}".format(j + 1)) if __name__ == '__main__': import time for dataset in ("balloon1.0", "balloon1.5"): _x, _y = DataUtil.get_dataset(dataset, "../../_Data/{}.txt".format(dataset)) learning_time = time.time() nb = MultinomialNB() nb.fit(_x, _y) learning_time = time.time() - learning_time print("=" * 30) print(dataset) print("-" * 30) estimation_time = time.time() nb.evaluate(_x, _y) estimation_time = time.time() - estimation_time print("Model building : {:12.6} s\n" "Estimation : {:12.6} s\n" "Total : {:12.6} s".format( learning_time, estimation_time, learning_time + estimation_time))
# "Model building : {:12.6} s\n" # "Estimation : {:12.6} s\n" # "Total : {:12.6} s".format( # learning_time, estimation_time, # learning_time + estimation_time # ) # ) whether_continuous = [False] * 16 continuous_lst = [0, 5, 9, 11, 12, 13, 14] for cl in continuous_lst: whether_continuous[cl] = True train_num = 40000 data_time = time.time() (x_train, y_train), (x_test, y_test) = DataUtil.get_dataset( "bank1.0", "../../_Data/bank1.0.txt", train_num=train_num) data_time = time.time() - data_time learning_time = time.time() nb = MergedNB(whether_continuous=whether_continuous) nb.fit(x_train, y_train) learning_time = time.time() - learning_time estimation_time = time.time() nb.evaluate(x_train, y_train) nb.evaluate(x_test, y_test) estimation_time = time.time() - estimation_time print( "Data cleaning : {:12.6} s\n" "Model building : {:12.6} s\n" "Estimation : {:12.6} s\n" "Total : {:12.6} s".format( data_time, learning_time, estimation_time,
def main(): log = "" nn = NNDist() save = False load = False show_loss = True train_only = False visualize = False verbose = 2 lr = 0.001 lb = 0.001 epoch = 10 record_period = 1 timing = Timing(enabled=True) timing_level = 1 x, y = DataUtil.get_dataset("mnist", "../../_Data/mnist.txt", quantized=True, one_hot=True) if not load: # nn.add("ReLU", (x.shape[1], 24)) # nn.add("ReLU", (24, )) # nn.add("CrossEntropy", (y.shape[1], )) x = x.reshape(len(x), 1, 28, 28) nn.add("ConvReLU", (x.shape[1:], (32, 3, 3))) nn.add("ConvReLU", ((32, 3, 3), )) nn.add("MaxPool", ((3, 3), ), 2) nn.add("ConvNorm") nn.add("ConvDrop") nn.add("ConvReLU", ((64, 3, 3), ), std=0.01) nn.add("ConvReLU", ((64, 3, 3), ), std=0.01) nn.add("AvgPool", ((3, 3), ), 2) nn.add("ConvNorm") nn.add("ConvDrop") nn.add("ConvReLU", ((32, 3, 3), )) nn.add("ConvReLU", ((32, 3, 3), )) nn.add("AvgPool", ((3, 3), ), 2) nn.add("ReLU", (512, )) nn.add("Identical", (64, )) nn.add("Normalize", activation="ReLU") nn.add("Dropout") nn.add("CrossEntropy", (y.shape[1], )) nn.optimizer = "Adam" nn.preview() nn.feed_timing(timing) nn.fit(x, y, lr=lr, lb=lb, epoch=epoch, batch_size=256, record_period=record_period, show_loss=show_loss, train_only=train_only, do_log=True, verbose=verbose, visualize=visualize) if save: nn.save() nn.draw_results() else: nn.load("Models/Model") nn.feed(x, y) nn.preview() nn.fit(epoch=5, lr=lr, lb=lb, verbose=verbose) if visualize: nn.visualize2d() nn.draw_results() acc = nn.estimate(x, y)[0] log += "Whole set Accuracy : {:12.6} %".format(100 * acc) + "\n" print() print("=" * 30 + "\n" + "Results\n" + "-" * 30) print(log) timing.show_timing_log(timing_level)
def main(): log = "" nn = NNDist() save = False load = False show_loss = True train_only = False do_log = True verbose = 2 lr = 0.001 lb = 0.001 epoch = 5 record_period = 1 weight_scale = 0.001 optimizer = "Adam" nn.optimizer = optimizer timing = Timing(enabled=True) timing_level = 1 x, y = DataUtil.get_dataset("cifar10", "../../_Data/cifar10.txt", quantized=True, one_hot=True) draw = False img_shape = (3, 32, 32) x = x.reshape(len(x), *img_shape) if not load: nn.add("ConvReLU", (x.shape[1:], (32, 3, 3))) nn.add("ConvReLU", ((32, 3, 3),)) nn.add("MaxPool", ((3, 3),), 2) nn.add("ConvNorm") nn.add("ConvDrop") nn.add("ConvReLU", ((64, 3, 3),), std=0.01) nn.add("ConvReLU", ((64, 3, 3),), std=0.01) nn.add("AvgPool", ((3, 3),), 2) nn.add("ConvNorm") nn.add("ConvDrop") nn.add("ConvReLU", ((32, 3, 3),)) nn.add("ConvReLU", ((32, 3, 3),)) nn.add("AvgPool", ((3, 3),), 2) nn.add("ReLU", (512, )) nn.add("Identical", (64, ), apply_bias=False) nn.add("Normalize", activation="ReLU") nn.add("Dropout") nn.add("CrossEntropy", (y.shape[1], )) nn.preview() nn.feed_timing(timing) nn.fit(x, y, lr=lr, lb=0, epoch=epoch, weight_scale=weight_scale, record_period=record_period, show_loss=show_loss, train_only=train_only, do_log=do_log, verbose=verbose) # nn.draw_results() if save: nn.save() if draw: # nn.draw_conv_weights() nn.draw_conv_series(x[:3], img_shape) else: nn.load() nn.feed(x, y) print("Optimizer: " + nn.optimizer) nn.preview() nn.fit(epoch=1, lr=lr, lb=lb, verbose=verbose) # nn.fit(x, y, x_cv, y_cv, x_test, y_test, epoch=1, lr=lr, lb=lb, verbose=verbose) if draw: # nn.draw_conv_weights() nn.draw_conv_series(x[:3], img_shape) nn.draw_results() acc = nn.evaluate(x, y)[0] log += "Test set Accuracy : {:12.6} %".format(100 * acc) + "\n" print("=" * 30 + "\n" + "Results\n" + "-" * 30) print(log) timing.show_timing_log(timing_level)
def main(): save = False load = False show_loss = True train_only = False verbose = 2 lr = 0.001 lb = 0.001 epoch = 10 record_period = 1 x, y = DataUtil.get_dataset("mnist", "../../_Data/mnist.txt", quantized=True, one_hot=True) x = x.reshape(len(x), 1, 28, 28) if not load: nn = NNDist() # nn.add("ReLU", (x.shape[1], 24)) # nn.add("ReLU", (24, )) # nn.add("CrossEntropy", (y.shape[1], )) nn.add("ConvReLU", (x.shape[1:], (32, 3, 3))) nn.add("ConvReLU", ((32, 3, 3), )) nn.add("MaxPool", ((3, 3), ), 2) nn.add("ConvNorm") nn.add("ConvDrop") nn.add("ConvReLU", ((64, 3, 3), ), std=0.01) nn.add("ConvReLU", ((64, 3, 3), ), std=0.01) nn.add("AvgPool", ((3, 3), ), 2) nn.add("ConvNorm") nn.add("ConvDrop") nn.add("ConvReLU", ((32, 3, 3), )) nn.add("ConvReLU", ((32, 3, 3), )) nn.add("AvgPool", ((3, 3), ), 2) nn.add("ReLU", (512, )) nn.add("Identical", (64, )) nn.add("Normalize", activation="ReLU") nn.add("Dropout") nn.add("CrossEntropy", (y.shape[1], )) nn.optimizer = "Adam" nn.preview(verbose=verbose) nn.fit(x, y, lr=lr, lb=lb, epoch=epoch, batch_size=256, record_period=record_period, show_loss=show_loss, train_only=train_only, do_log=True, tensorboard_verbose=1, verbose=verbose) if save: nn.save() else: nn = NNFrozen() nn.load() nn.preview() nn.evaluate(x, y) nn.show_timing_log()
plt.bar(tmp_x - 0.35 * c, self._data[j][c, :], width=0.35, facecolor=colors[self.label_dict[c]], edgecolor="white", label=u"class: {}".format(self.label_dict[c])) plt.xticks([i for i in range(sj + 2)], [""] + [rev_dict[i] for i in range(sj)] + [""]) plt.ylim(0, 1.0) plt.legend() if not save: plt.show() else: plt.savefig("d{}".format(j + 1)) if __name__ == '__main__': import time for dataset in ("balloon1.0", "balloon1.5"): _x, _y = DataUtil.get_dataset(dataset, "../../_Data/{}.txt".format(dataset)) learning_time = time.time() nb = MultinomialNB() nb.fit(_x, _y) learning_time = time.time() - learning_time print("=" * 30) print(dataset) print("-" * 30) estimation_time = time.time() nb.evaluate(_x, _y) estimation_time = time.time() - estimation_time print( "Model building : {:12.6} s\n" "Estimation : {:12.6} s\n" "Total : {:12.6} s".format( learning_time, estimation_time,
animation_params = { "show": False, "mp4": False, "period": 50, "dense": 400, "draw_background": True } kp = KP(animation_params=animation_params) kp.fit(xs, ys, kernel="poly", p=12, epoch=200) kp.evaluate(xs, ys) kp.visualize2d(xs, ys, dense=400) kp = GDKP(animation_params=animation_params) kp.fit(xs, ys, kernel="poly", p=12, epoch=10000) kp.evaluate(xs, ys) kp.visualize2d(xs, ys, dense=400) (x_train, y_train), (x_test, y_test), *_ = DataUtil.get_dataset( "mushroom", "../_Data/mushroom.txt", n_train=100, quantize=True, tar_idx=0) y_train[y_train == 0] = -1 y_test[y_test == 0] = -1 kp = KP() logs = [log[0] for log in kp.fit( x_train, y_train, metrics=["acc"], x_test=x_test, y_test=y_test )] kp.evaluate(x_train, y_train) kp.evaluate(x_test, y_test) plt.figure() plt.title(kp.title) plt.plot(range(len(logs)), logs) plt.show()
# # xs, ys = DataUtil.gen_xor(one_hot=False) # ys[ys == 0] = -1 # perceptron = KernelPerceptron() # _logs = [_log[0] for _log in perceptron.fit( # xs, ys, metrics=["acc"], epoch=10 ** 5 # )] # # perceptron.fit(xs, ys, kernel="rbf", epoch=10 ** 6) # # perceptron.fit(xs, ys, p=12, epoch=10 ** 5) # perceptron.evaluate(xs, ys) # perceptron.visualize2d(xs, ys, dense=400) (x_train, y_train), (x_test, y_test), *_ = DataUtil.get_dataset("mushroom", "../_Data/mushroom.txt", train_num=100, quantize=True, tar_idx=0) y_train[y_train == 0] = -1 y_test[y_test == 0] = -1 perceptron = KernelPerceptron() _logs = [ _log[0] for _log in perceptron.fit( x_train, y_train, metrics=["acc"], x_test=x_test, y_test=y_test) ] perceptron.evaluate(x_train, y_train) perceptron.evaluate(x_test, y_test) plt.figure() plt.title(perceptron.title)
plt.figure() plt.title(title) for c in range(len(self.label_dic)): plt.plot(tmp_x, [self._data[j][c](xx) for xx in tmp_x], c=colors[self.label_dic[c]], label="class: {}".format(self.label_dic[c])) plt.xlim(x_min-0.2*gap, x_max+0.2*gap) plt.legend() if not save: plt.show() else: plt.savefig("d{}".format(j + 1)) if __name__ == '__main__': import time xs, ys = DataUtil.get_dataset("mushroom", "../../_Data/mushroom.txt", tar_idx=0) nb = MultinomialNB() nb.feed_data(xs, ys) xs, ys = nb["x"].tolist(), nb["y"].tolist() train_num = 6000 x_train, x_test = xs[:train_num], xs[train_num:] y_train, y_test = ys[:train_num], ys[train_num:] learning_time = time.time() nb = GaussianNB() nb.fit(x_train, y_train) learning_time = time.time() - learning_time estimation_time = time.time() nb.evaluate(x_train, y_train)
idx += 1 return x if __name__ == '__main__': import time whether_continuous = [False] * 16 continuous_lst = [0, 5, 9, 11, 12, 13, 14] for cl in continuous_lst: #查看数据集,设置对应的特征是否连续还是离散 whether_continuous[cl] = True train_num = 40000 data_time = time.time() (x_train, y_train), (x_test, y_test) = DataUtil.get_dataset("bank1.0", "../Data/bank1.0.txt", n_train=train_num) data_time = time.time() - data_time learning_time = time.time() nb = MergedNB(whether_continuous=whether_continuous) nb.fit(x_train, y_train) learning_time = time.time() - learning_time estimation_time = time.time() nb.evaluate(x_train, y_train) nb.evaluate(x_test, y_test) estimation_time = time.time() - estimation_time nb.show_timing_log()
def predict(self, x, bound=None): if bound is None: _matrix = np.array([_tree.predict(x) for _tree in self._trees]).T else: _matrix = np.array( [_tree.predict(x) for _tree in self._trees[:bound]]).T return np.array([RandomForest.most_appearance(rs) for rs in _matrix]) if __name__ == '__main__': import time train_num = 100 (x_train, y_train), (x_test, y_test) = DataUtil.get_dataset("mushroom", "../_Data/mushroom.txt", train_num=train_num, tar_idx=0) learning_time = time.time() forest = RandomForest() forest.fit(x_train, y_train) learning_time = time.time() - learning_time estimation_time = time.time() forest.estimate(x_train, y_train) forest.estimate(x_test, y_test) estimation_time = time.time() - estimation_time print("Model building : {:12.6} s\n" "Estimation : {:12.6} s\n" "Total : {:12.6} s".format( learning_time, estimation_time, learning_time + estimation_time)) forest.show_timing_log()
def main(): log = "" nn = NNDist() save = False load = False show_loss = True train_only = False do_log = True verbose = 4 lr = 0.001 lb = 0.001 epoch = 10 record_period = 1 weight_scale = 0.001 optimizer = "Adam" nn.optimizer = optimizer x, y = DataUtil.get_dataset("cifar10", "../../../_Data/cifar10.txt", quantized=True, one_hot=True) draw = True img_shape = (3, 32, 32) x = x.reshape(len(x), *img_shape) if not load: nn.add("ConvReLU", (x.shape[1:], (32, 3, 3))) nn.add("ConvReLU", ((32, 3, 3),)) nn.add("MaxPool", ((3, 3),), 2) nn.add("ConvNorm") nn.add("ConvDrop") nn.add("ConvReLU", ((64, 3, 3),), std=0.01) nn.add("ConvReLU", ((64, 3, 3),), std=0.01) nn.add("AvgPool", ((3, 3),), 2) nn.add("ConvNorm") nn.add("ConvDrop") nn.add("ConvReLU", ((32, 3, 3),)) nn.add("ConvReLU", ((32, 3, 3),)) nn.add("AvgPool", ((3, 3),), 2) nn.add("ReLU", (512, )) nn.add("Identical", (64, ), apply_bias=False) nn.add("Normalize", activation="ReLU") nn.add("Dropout") nn.add("CrossEntropy", (y.shape[1], )) nn.preview() nn.fit(x, y, lr=lr, lb=0, epoch=epoch, weight_scale=weight_scale, record_period=record_period, show_loss=show_loss, train_only=train_only, do_log=do_log, verbose=verbose) nn.draw_results() if save: nn.save() if draw: # nn.draw_conv_weights() nn.draw_conv_series(x[:3], img_shape) else: nn.load() print("Optimizer: " + nn.optimizer) nn.preview() nn.fit(x, y, epoch=1, lr=lr, lb=lb, verbose=verbose) # nn.fit(x, y, x_cv, y_cv, x_test, y_test, epoch=1, lr=lr, lb=lb, verbose=verbose) if draw: # nn.draw_conv_weights() nn.draw_conv_series(x[:3], img_shape) nn.draw_results() acc = nn.evaluate(x, y)[0] log += "Test set Accuracy : {:12.6} %".format(100 * acc) + "\n" print("=" * 30 + "\n" + "Results\n" + "-" * 30) print(log) nn.show_timing_log()