Example #1
0
 def calculate_storage_capactiy(self, output_params={}):
     """
     Calculates the storage capacity of the BiNAM, given the expected output
     data and number of ones in the output. Returns the information, the
     output matrix and the error counts.
     """
     mat_out_res = self.calculate_output_matrix(output_params)
     N, n = mat_out_res.shape
     errs = entropy.calculate_errs(mat_out_res, self["mat_out"])
     I = entropy.entropy_hetero(errs, n, self["data_params"]["n_ones_out"])
     return I, mat_out_res, errs
Example #2
0
 def calculate_storage_capactiy(self, output_params={}):
     """
     Calculates the storage capacity of the BiNAM, given the expected output
     data and number of ones in the output. Returns the information, the
     output matrix and the error counts.
     """
     mat_out_res = self.calculate_output_matrix(output_params)
     N, n = mat_out_res.shape
     errs = entropy.calculate_errs(mat_out_res, self["mat_out"])
     I = entropy.entropy_hetero(errs, n, self["data_params"]["n_ones_out"])
     return I, mat_out_res, errs
Example #3
0
    def calculate_max_storage_capacity(self):
        """
        Calculates the maximum theoretical storage capacity for this network.
        """
        if hasattr(self["mat_out"], "shape") and hasattr(self["mat_in"], "shape"):
            _, m = self["mat_in"].shape
            _, n = self["mat_out"].shape
            mem = binam.BiNAM(m, n)
        else:
            mem = binam.BiNAM(self["data_params"]["n_bits_in"], self["data_params"]["n_bits_out"])
        mem.train_matrix(self["mat_in"], self["mat_out"])
        mat_out_ref = mem.evaluate_matrix(self["mat_in"])

        N, n = mat_out_ref.shape
        errs_ref = entropy.calculate_errs(mat_out_ref, self["mat_out"])
        I_ref = entropy.entropy_hetero(errs_ref, n, self["data_params"]["n_ones_out"])
        return I_ref, mat_out_ref, errs_ref
Example #4
0
    def calculate_max_storage_capacity(self):
        """
        Calculates the maximum theoretical storage capacity for this network.
        """
        if hasattr(self["mat_out"], "shape") and hasattr(self["mat_in"],
                                                         "shape"):
            _, m = self["mat_in"].shape
            _, n = self["mat_out"].shape
            mem = binam.BiNAM(m, n)
        else:
            mem = binam.BiNAM(
                self["data_params"]["n_bits_in"],
                self["data_params"]["n_bits_out"])
        mem.train_matrix(self["mat_in"], self["mat_out"])
        mat_out_ref = mem.evaluate_matrix(self["mat_in"])

        N, n = mat_out_ref.shape
        errs_ref = entropy.calculate_errs(mat_out_ref, self["mat_out"])
        I_ref = entropy.entropy_hetero(errs_ref, n,
                                       self["data_params"]["n_ones_out"])
        return I_ref, mat_out_ref, errs_ref
Example #5
0
i = 0
for p in xs:
    print("Iteration: ", p)

    # Introduce some errors
    X_part_p0 = np.minimum(X, (np.random.random((n_samples, n_bits)) >= p))
    X_part_p1 = np.maximum(X, (np.random.random((n_samples, n_bits)) < p))
    Y_part_out_p0_adap = M.evaluate_matrix(X_part_p0)
    Y_part_out_p1_adap = M.evaluate_matrix(X_part_p1)
    Y_part_out_p0_fix = M.evaluate_matrix(X_part_p0, threshold=n_ones)
    Y_part_out_p1_fix = M.evaluate_matrix(X_part_p1, threshold=n_ones)

    # Calculate the errors and the entropy
    errs = entropy.calculate_errs(Y_part_out_p0_adap, Y)
    info_p0_adap[i] = entropy.entropy_hetero(errs,
                                             n_bits_out=n_bits,
                                             n_ones_out=n_ones)
    fps_p0_adap[i] = np.array(map(lambda x: x["fp"], errs))
    fns_p0_adap[i] = np.array(map(lambda x: x["fn"], errs))

    errs = entropy.calculate_errs(Y_part_out_p1_adap, Y)
    info_p1_adap[i] = entropy.entropy_hetero(errs,
                                             n_bits_out=n_bits,
                                             n_ones_out=n_ones)
    fps_p1_adap[i] = np.array(map(lambda x: x["fp"], errs))
    fns_p1_adap[i] = np.array(map(lambda x: x["fn"], errs))

    errs = entropy.calculate_errs(Y_part_out_p0_fix, Y)
    info_p0_fix[i] = entropy.entropy_hetero(errs,
                                            n_bits_out=n_bits,
                                            n_ones_out=n_ones)
Example #6
0
i = 0
for p in xs:
    print("Iteration: ", p)

    # Introduce some errors
    X_part_p0 = np.minimum(X, (np.random.random((n_samples, n_bits)) >= p))
    X_part_p1 = np.maximum(X, (np.random.random((n_samples, n_bits)) < p))
    Y_part_out_p0_adap = M.evaluate_matrix(X_part_p0)
    Y_part_out_p1_adap = M.evaluate_matrix(X_part_p1)
    Y_part_out_p0_fix = M.evaluate_matrix(X_part_p0, threshold=n_ones)
    Y_part_out_p1_fix = M.evaluate_matrix(X_part_p1, threshold=n_ones)

    # Calculate the errors and the entropy
    errs = entropy.calculate_errs(Y_part_out_p0_adap, Y)
    info_p0_adap[i] = entropy.entropy_hetero(errs, n_bits_out=n_bits, n_ones_out=n_ones)
    fps_p0_adap[i] = np.array(map(lambda x: x["fp"], errs))
    fns_p0_adap[i] = np.array(map(lambda x: x["fn"], errs))

    errs = entropy.calculate_errs(Y_part_out_p1_adap, Y)
    info_p1_adap[i] = entropy.entropy_hetero(errs, n_bits_out=n_bits, n_ones_out=n_ones)
    fps_p1_adap[i] = np.array(map(lambda x: x["fp"], errs))
    fns_p1_adap[i] = np.array(map(lambda x: x["fn"], errs))

    errs = entropy.calculate_errs(Y_part_out_p0_fix, Y)
    info_p0_fix[i] = entropy.entropy_hetero(errs, n_bits_out=n_bits, n_ones_out=n_ones)
    fps_p0_fix[i] = np.array(map(lambda x: x["fp"], errs))
    fns_p0_fix[i] = np.array(map(lambda x: x["fn"], errs))

    errs = entropy.calculate_errs(Y_part_out_p1_fix, Y)
    info_p1_fix[i] = entropy.entropy_hetero(errs, n_bits_out=n_bits, n_ones_out=n_ones)
for s in xs:
    print("Iteration: ", s)
    # Train the new sample
    for s in xrange(s_old, s):
        M.train(X[s], Y[s])
    s_old = s

    # Evaluate the sample
    X_part = X[0:(s + 1)]
    Y_part = Y[0:(s + 1)]
    Y_part_out = M.evaluate_matrix(X_part)

    # Calculate the errors and the entropy
    errs = entropy.calculate_errs(Y_part_out, Y_part)
    info[i] = entropy.entropy_hetero(errs, n_bits_out=n_bits, n_ones_out=n_ones)
    n_false_positives[i] = np.sum(map(lambda x: x["fp"], errs))
    n_false_negatives[i] = np.sum(map(lambda x: x["fn"], errs))
    n_false_positives_mean[i] = np.mean(map(lambda x: x["fp"], errs))
    n_false_negatives_mean[i] = np.mean(map(lambda x: x["fn"], errs))
    n_false_positives_min[i] = np.min(map(lambda x: x["fp"], errs))
    n_false_negatives_min[i] = np.min(map(lambda x: x["fn"], errs))
    n_false_positives_max[i] = np.max(map(lambda x: x["fp"], errs))
    n_false_negatives_max[i] = np.max(map(lambda x: x["fn"], errs))

    i = i + 1


figsize = (cm2inch(11.8), cm2inch(6))

print("Plotting information...")