예제 #1
0
    def test_ksvd_normal_input(self):
        n_nonzero_coefs = 4
        n_samples = 512
        n_features = 32
        n_components = 24
        max_iter = 500

        A0, X = generate_dictionary_and_samples(n_samples, n_features, n_components, n_nonzero_coefs)
        model = KSVD(n_components=n_components, transform_n_nonzero_coefs=n_nonzero_coefs, max_iter=max_iter,
                     method='normal')
        model.fit(X)

        # check error of learning
        self.assertTrue(model.error_[-1] < 10)
        self.assertTrue(model.n_iter_ <= max_iter)

        # check estimated dictionary
        norm = np.linalg.norm(model.components_ - A0, ord='fro')
        self.assertTrue(norm < 15)

        # check reconstructed data
        code = model.transform(X)
        reconstructed = np.dot(code, model.components_)
        reconstruct_error = np.linalg.norm(reconstructed - X, ord='fro')
        self.assertTrue(reconstruct_error < 15)
예제 #2
0
    def test_transform_with_mask(self):
        n_nonzero_coefs = 4
        n_samples = 128
        n_features = 32
        n_components = 16
        max_iter = 10
        missing_value = 0

        A0, X = generate_dictionary_and_samples(n_samples, n_features,
                                                n_components, n_nonzero_coefs)
        X[X < 0.1] = missing_value
        mask = np.where(X == missing_value, 0, 1)

        model = KSVD(n_components=n_components,
                     transform_n_nonzero_coefs=n_nonzero_coefs,
                     max_iter=max_iter,
                     missing_value=missing_value,
                     method='normal')
        model.fit(X)

        # check error of learning
        code = model.transform(X)
        err = np.linalg.norm(mask * (X - code.dot(model.components_)), 'fro')
        self.assertTrue(err <= model.error_[0])
        self.assertTrue(model.n_iter_ <= max_iter)
예제 #3
0
    def test_transform(self):
        n_nonzero_coefs = 4
        n_samples = 128
        n_features = 32
        n_components = 24
        max_iter = 500

        A0, X = generate_dictionary_and_samples(n_samples, n_features, n_components, n_nonzero_coefs)
        model = KSVD(n_components=n_components, transform_n_nonzero_coefs=n_nonzero_coefs, max_iter=max_iter,
                     method='normal')
        model.fit(X)

        # check error of learning
        code = model.transform(X)
        err = np.linalg.norm(X - code.dot(model.components_), 'fro')
        self.assertTrue(err <= model.error_[-1])
        self.assertTrue(model.n_iter_ <= max_iter)
예제 #4
0
im = cv2.cvtColor(im, cv2.COLOR_BGR2GRAY)  #cv2.COLOR_BGR2RGB
im = cv2.resize(im, dsize=(128, 128), interpolation=cv2.INTER_CUBIC) / 256.0
im = np.clip(im, 0.001, 0.999)
plt.title("origin")
plt.imshow(im, vmin=0.0, vmax=1.0)
plt.show()

ksvd = KSVD(n_components=12, transform_n_nonzero_coefs=None, n_jobs=12)
ksvd.fit(im.reshape(-1, 64).astype(np.float64))

D = ksvd.components_.reshape(-1, 8, 8).astype(np.float64)
for i in range(12):
    plt.subplot(3, 4, i + 1)
    plt.imshow(D[i], vmin=0.0, vmax=1.0)
    plt.axis('off')
plt.show()

X = ksvd.transform(im.reshape(-1, 64).astype(np.float64))
plt.title("X")
plt.imshow(X, vmin=0.0, vmax=1.0)
plt.show()

plt.title("Re")
_y = np.dot(X, ksvd.components_)
_y = _y.reshape(128, 128).astype(np.float64)
plt.imshow(_y, vmin=0.0, vmax=1.0)
plt.show()

print(compare_psnr(im, _y))
print(compare_ssim(im, _y))