def test_constructor(self):
'''
Tests:
- is constructed
- dimensions
- data
- labels
'''
n_sample = 10
n_feature = 20
data = np.random.choice(a=(-1, 1),
p=(.5, .5),
size=(n_sample, n_feature))
labels = np.random.choice(a=(-1, 1), p=(.5, .5), size=(n_sample, ))
pt = Pattern(X=data, y=labels)
print(pt)
# constructor
assert pt.pattern is not None
# dimensions
assert pt.shape == (n_sample, n_feature)
# data
assert np.allclose(pt.data, data)
# labels
assert np.allclose(pt.labels, labels)
def test_predict(self):
params = {
'mag': MagP64,
'hidden': 3,
'max_iter': 1,
'seed': 135,
'damping': .05,
'accuracy': ('accurate', 'exact'),
'randfact': .1,
'epsil': .5,
'protocol': 'pseudo_reinforcement',
'size': 101,
'nth': 2,
'verbose': True
}
rfbp = rFBP(**params)
Xtest = np.ones(shape=(10, params['size']), dtype=int)
# check is fitted
with pytest.raises(NotFittedError):
pred_label = rfbp.predict(Xtest)
assert pred_label is not None
# train
pattern = Pattern().random(shape=(20, 101))
rfbp.fit(pattern)
pred_label = rfbp.predict(pattern)
predicted = rfbp.predict(pattern.data)
assert np.allclose(pred_label, predicted)
def test_load_pattern(self):
'''
Tests:
- if constructed
- dimensions
- data
- labels
'''
n_sample, n_feature = (3, 5)
data = np.ones(shape=(n_sample, n_feature), dtype=int)
y = -np.ones(shape=(n_sample), dtype=int)
with open('dummy.csv', 'w') as fp:
fp.write(','.join(map(str, y)))
fp.write('\n')
for i in data:
fp.write(','.join(map(str, i)))
fp.write('\n')
# constructed
pt = Pattern().load(filename='dummy.csv', delimiter=',', binary=False)
print(pt)
# dimensions
assert pt.shape == (n_sample, n_feature)
# data
values = set(np.ravel(pt.data))
assert 0 < len(values) <= 2
assert all(v in (-1, 1) for v in values)
assert np.allclose(np.ravel(pt.data), np.ravel(data))
# labels
values = set(pt.labels)
assert 0 < len(values) <= 2
assert all(v in (-1, 1) for v in values)
os.remove('dummy.csv')
with pytest.raises(ValueError):
pt = Pattern().load(filename=b'dummy.csv',
delimiter=',',
binary=False)
print(pt)
def test_constructor(self):
pattern = Pattern().random(shape=(20, 101))
params = {
'mag': MagT64,
'hidden': 3,
'max_iter': 1000,
'seed': 135,
'damping': .05,
'accuracy': ('accurate', 'exact'),
'randfact': .1,
'epsil': .5,
'protocol': 'pseudo_reinforcement',
'size': 101,
'nth': 2,
'verbose': False
}
rfbp = rFBP(**params)
assert params == rfbp.get_params()
print(rfbp)
# test wrong number of accuracy
params['accuracy'] = ('none')
with pytest.raises(TypeError):
rfbp = rFBP(**params)
assert params == rfbp.get_params()
# test wrong accuracies
params['accuracy'] = ('accurate', 'dummy')
with pytest.raises(ValueError):
rfbp = rFBP(**params)
assert params == rfbp.get_params()
# test wrong protocol
params['accuracy'] = ('accurate', 'exact')
params['protocol'] = 'none'
with pytest.raises(ValueError):
rfbp = rFBP(**params)
assert params == rfbp.get_params()
# test wrong magnetization
params['protocol'] = 'pseudo_reinforcement'
class Magnetization:
pass
params['mag'] = Magnetization
with pytest.raises(TypeError):
rfbp = rFBP(**params)
assert params == rfbp.get_params()
def test_wrong_input(self):
'''
Tests:
- test the check binary function
'''
n_sample = 10
n_feature = 20
data = np.random.uniform(low=0, high=1, size=(n_sample, n_feature))
labels = np.random.uniform(low=0, high=1, size=(n_sample, ))
with pytest.raises(ValueError):
pt = Pattern(X=data, y=labels)
def test_random_pattern(self):
'''
Tests:
- is constructed
- dimensions
- data
- labels
'''
n_sample = 10
n_feature = 20
# constructed
pt = Pattern().random(shape=(n_sample, n_feature))
print(pt)
# dimensions
assert pt.shape == (n_sample, n_feature)
# data
values = set(np.ravel(pt.data))
assert 0 < len(values) <= 2
assert all(v in (-1, 1) for v in values)
# labels
values = set(pt.labels)
assert 0 < len(values) <= 2
assert all(v in (-1, 1) for v in values)
with pytest.raises(ValueError):
pt = Pattern().random(shape=(n_sample, ))
print(pt)
with pytest.raises(ValueError):
pt = Pattern().random(shape=(-n_sample, n_feature))
print(pt)
def test_load_dump(self):
params = {
'mag': MagP64,
'hidden': 3,
'max_iter': 1,
'seed': 135,
'damping': .05,
'accuracy': ('accurate', 'exact'),
'randfact': .1,
'epsil': .5,
'protocol': 'pseudo_reinforcement',
'size': 101,
'nth': 2,
'verbose': True
}
rfbp = rFBP(**params)
with pytest.raises(NotFittedError):
rfbp.save_weights('dummy.csv', delimiter=',', binary=False)
pattern = Pattern().random(shape=(20, 101))
rfbp.fit(pattern)
W = rfbp.weights_
rfbp.save_weights('dummy.csv', delimiter=',', binary=False)
rfbp.load_weights('dummy.csv', delimiter=',', binary=False)
os.remove('dummy.csv')
assert np.allclose(W, rfbp.weights_)
assert rfbp.hidden == params['hidden']
W = rfbp.weights_
rfbp.save_weights('dummy.bin', binary=True)
rfbp.load_weights('dummy.bin', binary=True)
os.remove('dummy.bin')
assert np.allclose(W, rfbp.weights_)
assert rfbp.hidden == params['hidden']
def train ():
args = parse_args()
pattern = Pattern().load(filename=args.patterns, binary=args.bin, delimiter=args.delimiter)
args.mag = MagP64 if args.mag == 0 else MagT64
rfbp = rFBP(mag=args.mag,
hidden=args.hidden,
max_iter=args.iteration,
seed=args.seed,
damping=args.damping,
accuracy=args.accuracy,
randfact=args.randfact,
epsil=args.epsilon,
protocol=args.protocol,
size=args.steps,
nth=args.nth)
rfbp.fit(pattern)
rfbp.save_weights(args.outweights, args.delweights, args.binweights)
def test_null_constructor(self):
'''
Tests:
- is constructed
- dimensions
- data
- labels
'''
# constructor
pt = Pattern()
print(pt)
assert pt.pattern is None
# dimensions
assert pt.shape == (0, 0)
# data
assert pt.data is None
# labels
assert pt.labels is None
def test():
args = parse_args()
pattern = Pattern().load(filename=args.patterns,
binary=args.bin,
delimiter=args.delimiter)
rfbp = rFBP()
rfbp.load_weights(args.weights)
start_time = time.time()
predicted_labels = rfbp.predict(pattern)
elapsed_time = time.time() - start_time
print('{0}: Predicted in {1:.2f} seconds'.format(args.patterns,
elapsed_time))
if USE_SCORER:
scorer = Scorer()
scorer.evaluate(pattern.labels, predicted_labels)
print(scorer)
def test_fit(self):
K = 1
M = 3
N = 101
data1 = np.ones(shape=(M, N), dtype=int)
labels1 = np.ones(shape=(M, ), dtype=int)
data2 = -data1
labels2 = -labels1
# + / +
pattern1 = Pattern(X=data1, y=labels1)
# + / -
pattern2 = Pattern(X=data1, y=labels2)
# - / +
pattern3 = Pattern(X=data2, y=labels1)
# - / -
pattern4 = Pattern(X=data2, y=labels2)
for seed in np.random.randint(1, 99, 10):
params = {
'mag': MagP64,
'hidden': K,
'max_iter': 2,
'seed': seed,
'damping': .05,
'accuracy': ('exact', 'exact'),
'randfact': .1,
'epsil': .9,
'protocol': 'pseudo_reinforcement',
'size': 2,
'nth': 2,
'verbose': True
}
rfbp = rFBP(**params)
# train
rfbp.fit(pattern1)
assert np.sum(rfbp.weights_) > 0
rfbp.fit(pattern2)
assert np.sum(rfbp.weights_) < 0
rfbp.fit(pattern3)
assert np.sum(rfbp.weights_) < 0
rfbp.fit(pattern4)
assert np.sum(rfbp.weights_) > 0
params['mag'] = MagT64
rfbp = rFBP(**params)
# train
rfbp.fit(pattern1)
assert np.sum(rfbp.weights_) > 0
rfbp.fit(pattern2)
assert np.sum(rfbp.weights_) < 0
rfbp.fit(pattern3)
assert np.sum(rfbp.weights_) < 0
rfbp.fit(pattern4)
assert np.sum(rfbp.weights_) > 0
params['mag'] = MagP64
params['accuracy'] = ('accurate', 'accurate')
rfbp = rFBP(**params)
# train
rfbp.fit(pattern1)
assert np.sum(rfbp.weights_) > 0
rfbp.fit(pattern2)
assert np.sum(rfbp.weights_) < 0
rfbp.fit(pattern3)
assert np.sum(rfbp.weights_) < 0
rfbp.fit(pattern4)
assert np.sum(rfbp.weights_) > 0
params['mag'] = MagT64
rfbp = rFBP(**params)
# train
rfbp.fit(pattern1)
assert np.sum(rfbp.weights_) > 0
rfbp.fit(pattern2)
assert np.sum(rfbp.weights_) < 0
rfbp.fit(pattern3)
assert np.sum(rfbp.weights_) < 0
rfbp.fit(pattern4)
assert np.sum(rfbp.weights_) > 0
params['mag'] = MagP64
params['accuracy'] = ('none', 'none')
rfbp = rFBP(**params)
# train
rfbp.fit(pattern1)
assert np.sum(rfbp.weights_) > 0
rfbp.fit(pattern2)
assert np.sum(rfbp.weights_) < 0
rfbp.fit(pattern3)
assert np.sum(rfbp.weights_) < 0
rfbp.fit(pattern4)
assert np.sum(rfbp.weights_) > 0
params['mag'] = MagT64
rfbp = rFBP(**params)
# train
rfbp.fit(pattern1)
assert np.sum(rfbp.weights_) > 0
rfbp.fit(pattern2)
assert np.sum(rfbp.weights_) < 0
rfbp.fit(pattern3)
assert np.sum(rfbp.weights_) < 0
rfbp.fit(pattern4)
assert np.sum(rfbp.weights_) > 0
max_iter=1000,
seed=135,
damping=0.5,
accuracy=['accurate', 'exact'],
randfact=0.1,
epsil=0.5,
protocol='pseudo_reinforcement',
size=101,
nth=2)
start_time = time.time()
rfbp.fit(pattern, label)
elapsed_time = time.time() - start_time
pattern = Pattern(X=pattern, y=label)
print('{0}: Training completed in {1:.2f} seconds'.format(
pattern, elapsed_time))
predicted_labels = rfbp.predict(pattern)
print('Predictions:')
if USE_SCORER:
scorer = Scorer()
scorer.evaluate(pattern.labels, predicted_labels)
print(scorer)
else:
print(predicted_labels)