def test_init_super_som_raises():
# initialize without sample_weights:
with pytest.raises(AttributeError):
som = susi.SOMClassifier()
som.X_ = X_train
som.y_ = y_train
som._train_unsupervised_som()
som._set_bmus(som.X_)
som._init_super_som()
# initialize with placeholder in class list
with pytest.raises(ValueError):
som = susi.SOMClassifier()
som.X_ = X_train
som.placeholder_ = -1
som.y_ = np.full(shape=y_train.shape, fill_value="PLACEHOLDER")
som.sample_weights_ = np.full(fill_value=1., shape=(len(som.X_), 1))
som.labeled_indices_ = list(range(len(som.y_)))
som._train_unsupervised_som()
som._set_bmus(som.X_)
som._init_super_som()
# initialize with placeholder = missing_label_placeholder
with pytest.raises(ValueError):
som = susi.SOMClassifier(missing_label_placeholder=-999999)
som.X_ = X_train
som.y_ = y_train
som.sample_weights_ = np.full(fill_value=1., shape=(len(som.X_), 1))
som.labeled_indices_ = list(range(len(som.y_)))
som._train_unsupervised_som()
som._set_bmus(som.X_)
som._init_super_som()
print(y_train)
def test_modify_weight_matrix_supervised(
n_rows,
n_columns,
learning_rate,
dist_weight_matrix,
som_array,
random_state,
true_vector,
):
som = susi.SOMClassifier(n_rows=n_rows,
n_columns=n_columns,
random_state=random_state)
som.classes_ = [0, 1, 2]
som.class_weights_ = [1.0, 1.0, 1.0]
som.super_som_ = som_array
new_som = som._modify_weight_matrix_supervised(
dist_weight_matrix=dist_weight_matrix,
true_vector=true_vector,
learning_rate=learning_rate,
)
assert new_som.shape == (n_rows, n_columns, 1)
# raise because true_vector is None
som = susi.SOMClassifier(train_mode_supervised="online")
with pytest.raises(ValueError):
som._modify_weight_matrix_supervised(
dist_weight_matrix=np.array([1.0, 2.0]),
true_vector=None,
learning_rate=1.0,
)
# raise because learning_rate is None
with pytest.raises(ValueError):
som._modify_weight_matrix_supervised(
dist_weight_matrix=np.array([1.0, 2.0]),
true_vector=np.array([1.0, 2.0]),
learning_rate=None,
)
# raise because train_mode_supervised is wrong
som = susi.SOMClassifier(train_mode_supervised="wrong")
with pytest.raises(ValueError):
som._modify_weight_matrix_supervised(
dist_weight_matrix=np.array([1.0, 2.0]),
true_vector=np.array([1.0, 2.0]),
learning_rate=None,
)
def test_fit(train_mode_unsupervised, train_mode_supervised):
som = susi.SOMClassifier(n_rows=8,
n_columns=8,
train_mode_unsupervised=train_mode_unsupervised,
train_mode_supervised=train_mode_supervised,
random_state=3)
som.fit(X_train, y_train)
assert (som.score(X_test, y_test) >= 0.8)
def test_fit_semi(train_mode_unsupervised, train_mode_supervised):
som = susi.SOMClassifier(n_rows=5,
n_columns=5,
train_mode_unsupervised=train_mode_unsupervised,
train_mode_supervised=train_mode_supervised,
missing_label_placeholder=-1,
random_state=3)
som.fit(X_train, y_train_semi)
assert (som.score(X_test, y_test) > 0.5)
def test_predict_proba():
som = susi.SOMClassifier(
n_rows=8,
n_columns=8,
random_state=3,
)
som.fit(X_train, y_train)
proba = som.predict_proba(X_test)
assert isinstance(proba, np.ndarray)
def learn(self, i, conf):
train_X = self.train_Xs[i].copy()
train_y = self.train_ys[i].copy()
return susi.SOMClassifier(n_rows=conf[0],
n_columns=len(train_X[0]),
train_mode_unsupervised="online",
train_mode_supervised="online",
n_iter_unsupervised=conf[1],
n_iter_supervised=conf[2],
missing_label_placeholder=-1,
random_state=123).fit(train_X, train_y)
def test_change_class_proba(n_rows, n_columns, learningrate,
dist_weight_matrix, random_state, class_weight,
expected):
som = susi.SOMClassifier(n_rows=n_rows, n_columns=n_columns,
random_state=random_state)
new_som_array = som.change_class_proba(learningrate, dist_weight_matrix,
class_weight)
assert(new_som_array.shape == (n_rows, n_columns, 1))
assert(new_som_array.dtype == bool)
if expected is not None:
assert np.array_equal(new_som_array, expected.reshape((2, 2, 1)))
def test_init_super_som(n_rows, n_columns, do_class_weighting):
random_state = 3
som = susi.SOMClassifier(n_rows=n_rows,
n_columns=n_columns,
do_class_weighting=do_class_weighting,
random_state=random_state)
som.X_ = X_train
som.y_ = y_train
som.train_unsupervised_som()
som.set_bmus(som.X_)
som.init_super_som()
with pytest.raises(Exception):
som = susi.SOMClassifier(init_mode_supervised="random")
som.X_ = X_train
som.y_ = y_train
som.train_unsupervised_som()
som.set_bmus(som.X_)
som.init_super_som()
def test_init_super_som(n_rows, n_columns, do_class_weighting):
random_state = 3
som = susi.SOMClassifier(n_rows=n_rows,
n_columns=n_columns,
do_class_weighting=do_class_weighting,
random_state=random_state)
som.X_ = X_train
som.y_ = y_train
som.sample_weights_ = np.full(fill_value=1., shape=(len(som.X_), 1))
som._train_unsupervised_som()
som.labeled_indices_ = list(range(len(som.y_)))
som._set_bmus(som.X_)
som._init_super_som()
def test_set_placeholder(class_dtype):
som = susi.SOMClassifier()
som.placeholder_dict_ = {
"str": "PLACEHOLDER",
"int": -999999,
"float": -99.999,
}
som.class_dtype_ = class_dtype
if class_dtype != dict:
som._set_placeholder()
assert (type(som.placeholder_) == class_dtype)
else:
with pytest.raises(ValueError):
som._set_placeholder()
def test_modify_weight_matrix_supervised(n_rows, n_columns, learningrate,
dist_weight_matrix, som_array,
random_state, true_vector):
som = susi.SOMClassifier(n_rows=n_rows,
n_columns=n_columns,
random_state=random_state)
som.classes_ = [0, 1, 2]
som.class_weights_ = [1., 1., 1.]
som.super_som_ = som_array
new_som = som._modify_weight_matrix_supervised(
dist_weight_matrix=dist_weight_matrix,
true_vector=true_vector,
learningrate=learningrate)
assert (new_som.shape == (n_rows, n_columns, 1))
def classification(self, algorithm="keras"):
"""
algorithm: "som" - self-organizing feature map algorithm function,
"keras" - neural network algorithm
:return: object of susi class
"""
self.train_test()
if algorithm.upper() == "KERAS":
model = load_model(self.model_path)
model = model.predict(self.x)
self.data_type = np.int8([np.argmax(el) for el in model])
elif algorithm.upper() == "SOM":
self.som = susi.SOMClassifier()
self.som.fit(self.x_train, self.y_train)
self.data_type = np.int8(self.som.predict(self.x))
def fit(self,
min_rows=1,
max_rows=20,
min_iter_unsup=100,
max_iter_unsup=500,
min_iter_sup=100,
max_iter_sup=500,
verbose=True):
acc_ones = []
acc_zeros = []
accs = []
if verbose:
print(
'-----------------------------------START SUSI OPTIMIZATION------------------------------------'
)
best = dict()
for (rows, iter_un, iter_su) in [
(x, a, b) for x in range(min_rows, max_rows + 1, 5)
for a in range(min_iter_unsup, max_iter_unsup + 1, 100)
for b in range(min_iter_sup, max_iter_sup + 1, 100)
]:
metric = []
for i in range(self.K):
train_X = self.train_Xs[i].copy()
train_y = self.train_ys[i].copy()
test_X = self.val_Xs[i].copy()
test_y = self.val_ys[i].copy()
model = susi.SOMClassifier(n_rows=rows,
n_columns=len(train_X[0]),
train_mode_unsupervised="online",
train_mode_supervised="online",
n_iter_unsupervised=iter_un,
n_iter_supervised=iter_su,
missing_label_placeholder=-1,
random_state=123)
model.fit(train_X, train_y)
y_pred = model.predict(test_X)
# evaluating by accuracy #
# counting respectively True Positives, True Negatives and Correct count values
ones = [(x, y) for (x, y) in zip(y_pred, test_y)
if x == y and y == 1.0]
zeros = [(x, y) for (x, y) in zip(y_pred, test_y)
if x == y and y == 0.0]
nc = [(x, y) for (x, y) in zip(y_pred, test_y) if x == y]
one = test_y.count(1.0)
zero = test_y.count(0.0)
# accuracy calculation
if verbose:
print(f'{i} - fold')
acc_ones.append(division(len(ones), one))
acc_zeros.append(division(len(zeros), zero))
accs.append(division(len(nc), len(y_pred)))
metric.append(
avg([division(len(ones), one),
division(len(zeros), zero)]))
best.setdefault(avg(metric), (rows, iter_un, iter_su))
if verbose:
print(
f'----------------------{rows},{iter_un},{iter_su}----------------------------'
)
print(f'total one: {avg(acc_ones)}')
print(f'total zero: {avg(acc_zeros)}')
print(f'total accuracy: {geo_avg(accs)}')
conf = best.get(np.array(list(best.keys())).max())
if verbose:
print(
'-----------------------------------RESUME SUSI OPTIMIZATION------------------------------------'
)
print(
f"best rows: {conf[0]} - best uns_it: {conf[1]} - best su_it: {conf[2]}"
)
print('susi learned')
return conf
def test_estimator_status():
check_estimator(susi.SOMClassifier())
# print (cnts)
# plt.hist(target, bins=9) # `density=False` would make counts
# plt.ylabel('Data Points')
# plt.xlabel('Classes')
# plt.show()
X = data
y = target
# print (X.shape[0])
kf = KFold(n_splits=5)
som = susi.SOMClassifier(
n_rows=50,
n_columns=50,
n_iter_unsupervised=10000,
n_iter_supervised=5000,
random_state=42,
)
k_fold_score = 0
index = 1
for train_index, test_index in kf.split(data):
X_train, X_test = X[train_index], X[test_index]
y_train, y_test = y[train_index], y[test_index]
data = X_train
target = y_train
data_class = {}
# print (X_train.shape,X_test.shape,y_train.shape,y_test.shape)
print("Running on fold ", index)
