def semiLabelSpreding(feature_extractor, generator, val_generator, kernel,
neighbors, gamma, alpha):
semi = LabelSpreading(kernel=kernel,
n_neighbors=neighbors,
gamma=gamma,
alpha=alpha,
tol=0.001,
max_iter=1000000)
features = feature_extractor.predict_generator(generator,
steps=generator.samples /
generator.batch_size,
verbose=1)
classes = generator.classes
for i in range(0, generator.samples):
if (generator.filenames[i][0] == 'N'):
classes[i] = -1
semi.fit(features, classes)
val_features = feature_extractor.predict_generator(
val_generator,
steps=val_generator.samples / val_generator.batch_size,
verbose=1)
predicted_classes = semi.predict(val_features)
return predicted_classes
def label_spreading(X_train, y_train, Xunlabelled, X_test, y_test):
#pca = randomized_PCA(X_train)
#X_train, X_test, y_train, y_test = cross_validation.train_test_split(tr_images, tr_labels, test_size=0.3)
#X = pca.transform(X)
#val_images = pca.transform(val_images)
#y= y[:]
X_train = X_train[:, :]
y_train = y_train[:]
Xunlabelled = Xunlabelled[:10000,:]
#import ipdb; ipdb.set_trace()
X_both = np.vstack((X_train, Xunlabelled))
y_both = np.append(y_train, -np.ones((Xunlabelled.shape[0],)))
label_prop_model = LabelSpreading(max_iter=100)
#random_unlabeled_points = np.where(np.random.random_integers(0, 1, size=len(y_train)))
#labels = np.copy(y_train)
#labels[random_unlabeled_points] = -1
label_prop_model.fit(np.copy(X_both), np.copy(y_both))
y_pred = label_prop_model.predict(np.copy(X_both))
print(y_pred)
def run_lp_bow_runtime_vocabulary(nbr, str_list, neighbors):
i = 0
avg_f1 = 0
avg_accuracy = 0
while i < 10:
dataset = Dataset(categories)
dataset.load_preprocessed(categories)
dataset.split_train_true(nbr)
print_v2_test_docs_vocabulary_labeled(categories)
dataset.load_preprocessed_test_vocabulary_labeled_in_use(categories)
vectorizer = CountVectorizer(vocabulary=Vocabulary.get_vocabulary(categories))
vectors = vectorizer.fit_transform(dataset.train['data'])
clf = LabelSpreading(kernel='knn', n_neighbors=neighbors).fit(vectors.todense(), dataset.train['target'])
test_vec = vectorizer.transform(dataset.test['data'])
pred = clf.predict(test_vec.todense())
avg_f1 += metrics.f1_score(dataset.test['target'], pred, average='macro')
avg_accuracy += clf.score(test_vec.todense(), dataset.test['target'])
i += 1
avg_accuracy = avg_accuracy/10
avg_f1 = avg_f1/10
str_list.extend(["KNN BOW runtime voc Avg f1: " + avg_f1.__str__(), "KNN BOW runtime vod Avg acc: "
+ avg_accuracy.__str__()])
print("Avg f1: " + avg_f1.__str__())
print("Avg acc: " + avg_accuracy.__str__())
def doLabelSpreading(self,X,y,**kwargs):
label_spread_model = LabelSpreading(**kwargs)
if self.verbose>2:
print("X, y shapes: ",X.shape,y.shape)
print(" y hist: ",np.histogram(y))
label_spread_model.fit(X, y)
if self.verbose>2: print("ls_predict:",np.histogram(label_spread_model.predict(X)) )
return label_spread_model.predict_proba(X)
def label_spreading(self, X_train, y, X_test):
clf = LabelSpreading()
X = np.concatenate((X_train.todense(), X_test.todense()), axis=0)
print("X shape now ", X.shape)
print("Y shape now ", y.shape)
clf.fit(X, y)
final_labels = clf.predict(X_test)
label_prob = clf.predict_proba(X_test)
print(compare_labels_probabilities().compare(label_prob, final_labels))
return final_labels, clf
def apply_notl(trainX, trainY, testX, testY, window, source_pos, target_pos):
#######################
### SEMI-SUPERVISED ###
########################
# Label Propagation
label_prop_model = LabelPropagation(kernel='knn')
label_prop_model.fit(trainX, trainY)
Y_Pred = label_prop_model.predict(testX);
acc_ss_propagation, acc_ss_propagation_INFO = check_accuracy(testY, Y_Pred)
# Label Spreading
label_prop_models_spr = LabelSpreading(kernel='knn')
label_prop_models_spr.fit(trainX, trainY)
Y_Pred = label_prop_models_spr.predict(testX);
acc_ss_spreading, acc_ss_spreading_INFO = check_accuracy(testY, Y_Pred)
########################
#### WITHOUT TL ########
########################
# LogisticRegression
modelLR = LogisticRegression()
modelLR.fit(trainX, trainY)
predLR = modelLR.predict(testX)
accLR, acc_LR_INFO = check_accuracy(testY, predLR)
# DecisionTreeClassifier
modelDT = tree.DecisionTreeClassifier()
modelDT.fit(trainX, trainY)
predDT = modelDT.predict(testX)
accDT, acc_DT_INFO = check_accuracy(testY, predDT)
# BernoulliNB
modelNB = BernoulliNB()
modelNB.fit(trainX, trainY)
predND = modelNB.predict(testX)
accNB, acc_NB_INFO = check_accuracy(testY, predND)
#
return pd.DataFrame(
[{
'window': window,
'source_position': source_pos,
'target_position': target_pos,
'acc_SS_propagation': acc_ss_propagation,
'acc_SS_propagation_INFO':acc_ss_propagation_INFO,
'acc_SS_spreading': acc_ss_spreading,
'acc_SS_spreading_INFO':acc_ss_spreading_INFO,
'acc_LR':accLR,
'acc_LR_INFO': str(acc_LR_INFO),
'acc_DT': accDT,
'acc_DT_INFO': str(acc_DT_INFO),
'acc_NB': accNB,
'acc_NB_INFO': str(acc_NB_INFO)
}]
)
def _semi_supervised_learning(self, data_matrix, target):
n_classes = len(set(target))
# if there are too few classes (e.g. less than -1 and at least 2 other classes)
# then just bail out and return the original target
# otherwise one cannot meaningfully spread the information of only one class
if n_classes > 2:
semi_supervised_estimator = LabelSpreading(kernel='knn', n_neighbors=self.n_neighbors)
semi_supervised_estimator.fit(data_matrix, target)
predicted_target = semi_supervised_estimator.predict(data_matrix)
predicted_target = self._clamp(target, predicted_target)
return predicted_target
else:
return target
def _semi_supervised_learning(self, data_matrix, target):
n_classes = len(set(target))
# if there are too few classes (e.g. less than -1 and at least 2 other classes)
# then just bail out and return the original target
# otherwise one cannot meaningfully spread the information of only one class
if n_classes > 2:
semi_supervised_estimator = LabelSpreading(
kernel='knn', n_neighbors=self.n_neighbors)
semi_supervised_estimator.fit(data_matrix, target)
predicted_target = semi_supervised_estimator.predict(data_matrix)
predicted_target = self._clamp(target, predicted_target)
return predicted_target
else:
return target
def semi_supervised_learning(data_matrix, target):
if -1 in list(target):
# if -1 is present in target do label spreading
from sklearn.semi_supervised import LabelSpreading
label_prop_model = LabelSpreading(kernel='knn', n_neighbors=5)
label_prop_model.fit(data_matrix, target)
pred_target = label_prop_model.predict(data_matrix)
extended_target = []
for pred_label, label in zip(pred_target, target):
if label != -1 and pred_label != label:
extended_target.append(label)
else:
extended_target.append(pred_label)
else:
extended_target = target
return np.array(extended_target)
def semi_supervised_learning(data_matrix, target):
if -1 in list(target):
# if -1 is present in target do label spreading
from sklearn.semi_supervised import LabelSpreading
label_prop_model = LabelSpreading(kernel='knn', n_neighbors=5)
label_prop_model.fit(data_matrix, target)
pred_target = label_prop_model.predict(data_matrix)
extended_target = []
for pred_label, label in zip(pred_target, target):
if label != -1 and pred_label != label:
extended_target.append(label)
else:
extended_target.append(pred_label)
else:
extended_target = target
return np.array(extended_target)
def augment_instances(self, X_train, y_train):
if self.args.num_unlabeled == 0:
return X_train, y_train
X_unlabeled = self.dataset.X_train_unlabeled
y_unlabeled = self.dataset.y_train_unlabeled
X_unlabeled = X_unlabeled.values
y_unlabeled = y_unlabeled.values
X_train_text = X_train[:, self.args.text_col]
self.fit_text(X_train_text, y_train)
X_train_rep = self.transform_text(X_train_text)
X_train_rep = self.augment_features(X_train_rep, X_train)
chunk_size = 1000
num_instances = X_unlabeled.shape[0]
num_cols = y_train.shape[1]
for row in tqdm(range(0, self.args.num_unlabeled, chunk_size),
desc='spreading labels in rows',
total=int(self.args.num_unlabeled / chunk_size)):
end_row = row + chunk_size
end_row = np.minimum(end_row, num_instances)
for col in tqdm(range(num_cols),
desc='spreading labels in cols',
leave=False):
X_unlabeled_rep = self.transform_text(
X_unlabeled[row:end_row, self.args.text_col])
X_unlabeled_rep = self.augment_features(
X_unlabeled_rep, X_unlabeled[row:end_row, :])
X_spread = np.append(X_train_rep, X_unlabeled_rep, axis=0)
y_spread = np.append(y_train[:, col],
y_unlabeled[row:end_row, col],
axis=0)
labeling = LabelSpreading()
labeling.fit(X_spread, y_spread)
y_unlabeled[row:end_row,
col] = labeling.predict(X_unlabeled_rep)
X_train = np.append(X_train, X_unlabeled[:row + chunk_size], axis=0)
y_train = np.append(y_train, y_unlabeled[:row + chunk_size], axis=0)
return X_train, y_train
class LabelSpreadingImpl:
def __init__(self, **hyperparams):
self._hyperparams = hyperparams
self._wrapped_model = Op(**self._hyperparams)
def fit(self, X, y=None):
if y is not None:
self._wrapped_model.fit(X, y)
else:
self._wrapped_model.fit(X)
return self
def predict(self, X):
return self._wrapped_model.predict(X)
def predict_proba(self, X):
return self._wrapped_model.predict_proba(X)
class LP:
def __init__(self, lmnn=False, max_iter=1000, lm_num=200):
# self.clf = LabelPropagation(kernel='knn',max_iter=1000,n_jobs=10,n_neighbors=25)
self.clf = LabelSpreading(kernel='knn',
n_neighbors=25,
max_iter=max_iter,
alpha=0.2,
n_jobs=-1)
self.lmnn = lmnn
self.lm_num = lm_num
if lmnn:
self.ml = LMNN(use_pca=False, max_iter=2000)
def fit(self, X, y):
if self.lmnn:
nonzero_index = np.nonzero(y)
index = random.sample(list(nonzero_index[0]), self.lm_num)
X_ = X[index]
y_ = y[index]
print('ml fitting')
self.ml.fit(X_, y_)
print('transform')
X = self.ml.transform(X)
print('lp fitting')
zero_index = np.nonzero(y == 0)
negetive_index = np.nonzero(y == -1)
positive_index = np.nonzero(y == 1)
y[zero_index] = -1
y[negetive_index] = 2
print(zero_index[0].shape, negetive_index[0].shape,
positive_index[0].shape)
self.clf.fit(X, y)
def predict(self, X):
print('lp predict')
if self.lmnn:
X = self.ml.transform(X)
y_pred = self.clf.predict(X)
negative_index = np.nonzero(y_pred == -1)
two_index = np.nonzero(y_pred == 2)
y_pred[negative_index] = 0
y_pred[two_index] = -1
return y_pred
def soft_clamping(kernel, xTrain, yTrain, MI=10000, k=3, g=0.6, a=0.1):
spread = LabelSpreading(kernel=kernel,
n_neighbors=k,
gamma=g,
alpha=a,
max_iter=MI,
n_jobs=-1)
spread.fit(xTrain, yTrain)
evaledY = spread.predict(xTrain)
#def stats(trainY,evaledY,expectedY,day_one): return
lm_to_b, lb_to_m, tp, tn, fp, fn, pred_day1, missed_day1 = stats(
yTrain, evaledY, yExpect, day_one)
results = [
'SC', kernel, k, g, a, lm_to_b, lb_to_m, tp, tn, fp, fn, pred_day1,
missed_day1
]
file_name = 'SC.csv'
write_csv(file_name, results)
def getLabelPropa(yale):
n = len(yale)
yale['labels'] = yale['Rank']
yale['labels'].loc[yale['Town'].isin(
['Greenwich', 'Westport', 'Fairfield', 'Trumbull', 'Ridgefield'])] = 1
#print(yale['labels'])
label = yale['labels']
yale = yale.select_dtypes(include=['float64', 'int64'])
label_prop_model = LabelSpreading(alpha=0.1,
kernel='rbf',
n_neighbors=3,
max_iter=300,
gamma=2)
yale = yale.drop(['labels'], axis=1)
yale = preprocessing.normalize(yale, axis=0, norm='max')
label_prop_model.fit(yale, label)
label = label_prop_model.predict(yale)
##print(label_prop_model.predict(yale))
#print(label_prop_model)
#print(label_prop_model.predict_proba(yale))
return label
def run_lp_tfidf(nbr, str_list, neighbors):
i = 0
avg_f1 = 0
avg_accuracy = 0
while i < 10:
dataset = Dataset(categories)
dataset.split_train_true(nbr)
vectorizer = TfidfVectorizer()
vectors = vectorizer.fit_transform(dataset.train['data'])
clf = LabelSpreading(kernel='knn', n_neighbors=neighbors).fit(vectors.todense(), dataset.train['target'])
test_vec = vectorizer.transform(dataset.test['data'])
pred = clf.predict(test_vec.todense())
avg_f1 += metrics.f1_score(dataset.test['target'], pred, average='macro')
avg_accuracy += clf.score(test_vec.todense(), dataset.test['target'])
i += 1
avg_accuracy = avg_accuracy/10
avg_f1 = avg_f1/10
str_list.extend(["KNN TF-IDF Avg f1: " + avg_f1.__str__(), "KNN TF-IDF Avg acc: " + avg_accuracy.__str__()])
print("Avg f1: " + avg_f1.__str__())
print("Avg acc: " + avg_accuracy.__str__())
class propgate_lables_predictor():
def __init__(self,X_unlabled,predictor):
self.X_unlabled=X_unlabled
self.prop_model = LabelSpreading(kernel='rbf',gamma=0.1,max_iter=1000,tol=0.001,n_jobs=-1,alpha=0.2)
self.predictor = predictor
def fit(self,X,y):
unlabled =self.X_unlabled#.head(500)
new_x, new_y_pre = pd.concat([pd.DataFrame(X), pd.DataFrame(unlabled.values)]), pd.concat([y, pd.DataFrame([-1] * len(unlabled))])
scale = StandardScaler()
self.prop_model.fit(scale.fit_transform(new_x), np.array(new_y_pre).ravel())
new_y_post = self.prop_model.predict(scale.transform(new_x))
pred_entropies = pd.Series(scipy.stats.entropy(self.prop_model.label_distributions_.T))
X_final = new_x.reset_index(drop=True)
pred_entropies.index = X_final.index
#pred_entropies[new_y_pre==-1] = 0 #they are known, making sure they are in
y_final = pd.concat([pd.Series(y), pd.Series(new_y_post[len(y):])])
y_final.index = X_final.index
cond = (~pred_entropies.isna()) & (pred_entropies < pred_entropies.iloc[len(y):].mean())
X_final = X_final.loc[cond,:]
y_final = y_final[cond]
print(len(X),'final amount of instances:',len(X_final))
self.predictor.fit(X_final,np.array(y_final).ravel())
def predict(self,X):
return self.predictor.predict(X)
def predict_proba(self,X):
return self.predictor.predict_proba(X)
def JSFS(X: np.ndarray, y: np.ndarray, test_X: np.ndarray, test_y: np.ndarray,
name: str):
# reference: Jiang, Bingbing, et al.
# "Joint semi-supervised feature selection and classification through Bayesian approach."
# Proceedings of the AAAI Conference on Artificial Intelligence. Vol. 33. 2019.
print('========== JSFS ==========')
# --- Input & Initialize---
# np.set_printoptions(threshold=np.inf)
n = len(X)
d = len(X[0])
y.resize((n, 1))
testSize = len(test_X)
# labeled sample ratio
# labelRatio = 0.5
labelRatio = CONFIG[name]['labelRatio']
l = int(n * labelRatio)
u = n - l
# γ and µ are super parameters
# Gamma = 0.001
Gamma = CONFIG[name]['Gamma']
# Mu = 0.9
Mu = CONFIG[name]['Mu']
# Beta = 0.005
Beta = 5
Omega = np.zeros((d, 1))
Omega[:] = 0.5
Lambda_vector = np.zeros((u, 1))
Lambda_vector[:] = 0.5
A = np.zeros((d, d))
for i in range(d):
A[i, i] = 0.001
C = np.zeros((u, u))
for i in range(u):
C[i, i] = 0.001
# --- Construct the affinity matrix S and graph Laplacian L via KNN ---
print('Construct the affinity matrix S and graph Laplacian L via KNN')
trainData_X = X
trainData_Y = y.ravel() # y and trainData_Y address the same memory
# replace the original -1 label with 0, because in this method -1 means no label
for i in range(n):
trainData_Y[i] = 0 if trainData_Y[i] == -1 else trainData_Y[i]
trainData_Y[l:] = -1
KNN = KNeighborsClassifier(n_neighbors=5)
KNN.fit(trainData_X[:l], trainData_Y[:l])
S = np.zeros((n, n))
D = np.zeros((n, n))
L = np.zeros((n, n))
for i in range(n):
for j in range(i, n):
if trainData_Y[i] == trainData_Y[j] and trainData_Y[i] != -1:
S[i][j] = 10
elif (trainData_Y[i] == -1
and trainData_Y[j] > -1) and (KNN.predict(
trainData_X[i:i + 1]) == trainData_Y[j]):
S[i][j] = 1
elif (trainData_Y[j] == -1
and trainData_Y[i] > -1) and (KNN.predict(
trainData_X[j:j + 1]) == trainData_Y[i]):
S[i][j] = 1
else:
S[i][j] = 0
S[j][i] = S[i][j]
D[i, i] = sum(S[i, :])
percent = 100 * (float((2 * n - i) * (i + 1)) / ((n + 1) * n))
show_str = ('[%%-%ds]' % 50) % (int(50 * percent / 100) * "#")
print('\r%s %d%%' % (show_str, percent), end='')
L = D - S
# --- Obtain the pseudo laber vector y_u via label progation ---
print('\nObtain the pseudo laber vector y_u via label progation')
LGC_rbf = LabelSpreading(kernel='knn',
gamma=20,
n_neighbors=7,
max_iter=150)
LGC_rbf.fit(trainData_X, trainData_Y)
trainData_Y[l:] = LGC_rbf.predict(trainData_X[l:])
# change 0 back to the -1
""" for i in range(n):
trainData_Y[i] = -1 if trainData_Y[i] == 0 else trainData_Y[i] """
# --- Data preprocessing - Normalized for X, y ---
# min_max_scaler = preprocessing.MinMaxScaler((0, 0.0001))
min_max_scaler = preprocessing.MinMaxScaler(
(0, CONFIG[name]['xMaxScaler']))
X = min_max_scaler.fit_transform(X)
test_X = min_max_scaler.transform(test_X)
# --- Convergence ---
B = Gamma * np.dot(np.dot(X.T, L), X)
Lambda = np.matlib.identity(n)
Sigma = np.zeros((n, 1))
E = np.zeros((n, n))
P = np.zeros((u, u))
k_lambda = np.zeros((u, 1))
Eu = np.zeros((u, u))
O = np.zeros((u, u))
Omega_old = np.ones((d, 1))
Lambda_vector_old = np.zeros((u, 1))
g_omega = np.zeros((d, 1))
H_omega = np.zeros((d, d))
Sig_omega = np.zeros((d, d))
g_lambda = np.zeros((u, 1))
H_lambda = np.zeros((u, u))
Sig_lambda = np.zeros((u, u))
G = np.zeros((d, d))
cnt = 0
while np.linalg.norm(Omega - Omega_old, ord=np.inf) > 0.001:
print('--------', cnt + 1, '--------')
for i in range(n):
if (i < l):
Sigma[i, 0] = 1 / (1 + np.exp(-1 * np.dot(X[i, :], Omega)))
E[i, i] = Sigma[i, 0] * (1 - Sigma[i, 0])
else:
Sigma[i, 0] = 1 / \
(1 + np.exp(-1 *
Lambda_vector[i-l, 0] * np.dot(X[i, :], Omega)))
E[i, i] *= Mu * Lambda_vector[i-l, 0] * \
Lambda_vector[i-l, 0] * Sigma[i, 0] * (1 - Sigma[i, 0])
Lambda[i, i] = Mu * Lambda_vector[i - l, 0]
P[i - l, i - l] = np.dot(X[i, :], Omega)
k_lambda[i-l, 0] = Beta * \
(1 - (1 / (1 + np.exp(-(Beta * Lambda_vector[i-l, 0])))))
Eu[i - l, i - l] = Sigma[i, 0] * (1 - Sigma[i, 0])
O[i - l, i - l] = Beta * Beta * (
1 / (1 + np.exp(-(Beta * Lambda_vector[i - l, 0])))) * (
1 - (1 /
(1 + np.exp(-(Beta * Lambda_vector[i - l, 0])))))
if (np.linalg.norm(g_omega[:, 0], ord=2) / d) < 0.001:
g_omega = np.dot(np.dot(X.T, Lambda), (y - Sigma)) - \
np.dot((A + B), Omega)
H_omega = -1 * (np.dot(np.dot(X.T, E), X) + A + B)
Sig_omega = -1 * np.linalg.inv(H_omega)
Omega_old = Omega.copy()
Omega = Omega - np.dot(np.linalg.inv(H_omega), g_omega)
print('gw:', np.mean(g_omega[:, 0]), ' gw_judge:',
(np.linalg.norm(g_omega[:, 0], ord=2) / d), 'w_max',
np.max(Omega, axis=0), 'w_min', np.min(Omega, axis=0))
for i in range(d):
if (Omega[i, 0] != 0) and (abs(Omega[i, 0]) < 0.001):
Omega[i, 0] = 0
if (np.linalg.norm(g_lambda[:, 0], ord=2) / u) < 0.001:
g_lambda = Mu * np.dot(P, (y[l:] - Sigma[l:])) - \
np.dot(C, Lambda_vector) + k_lambda
H_lambda = -1 * ((Mu * np.dot(np.dot(P.T, Eu), P)) + C + O)
Sig_lambda = -1 * np.linalg.inv(H_lambda)
Lambda_vector_old = Lambda_vector.copy()
Lambda_vector = Lambda_vector - \
np.dot(np.linalg.inv(H_lambda), g_lambda)
print('gl:', np.mean(g_lambda[:, 0]), ' gl_judge:',
(np.linalg.norm(g_lambda[:, 0], ord=2) / u), 'l_max',
np.max(Lambda_vector, axis=0), 'l_min',
np.min(Lambda_vector, axis=0))
for i in range(u):
if (Lambda_vector[i, 0] != 0) and (abs(Lambda_vector[i, 0]) <
0.001):
Lambda_vector[i, 0] = 0
G = np.dot(
np.dot(
np.dot(np.linalg.inv(A), B),
np.linalg.inv(
np.matlib.identity(d) + np.dot(np.linalg.inv(A), B))),
np.linalg.inv(A))
for i in range(d):
A[i,
i] = 1 / (Omega[i, 0] * Omega[i, 0] + G[i, i] + Sig_omega[i, i])
for i in range(u):
C[i, i] = 1 / (Lambda_vector[i, 0] * Lambda_vector[i, 0] +
Sig_lambda[i, i])
print('max_lambda_new-old',
np.linalg.norm(Lambda_vector - Lambda_vector_old, ord=np.inf))
print('max_omega_new-old', np.linalg.norm(Omega - Omega_old,
ord=np.inf))
cnt += 1
if cnt == 50:
break
# --- Test ---
predict_y = np.zeros(testSize)
predict_vector_y = np.dot(test_X, Omega).flatten()
predict_vector_y *= CONFIG[name]['yScaler']
threshold = CONFIG[name]['threshold']
for i in range(testSize):
if predict_vector_y[0, i] < threshold:
predict_y[i] = -1
else:
predict_y[i] = 1
print('predict_y:', predict_vector_y[0, :10])
tp = 0
fp = 0
fn = 0
tn = 0
for idx in range(len(test_y)):
if test_y[idx] == 1 and predict_y[idx] == 1:
tp += 1
elif test_y[idx] == 1 and predict_y[idx] == -1:
fn += 1
elif test_y[idx] == -1 and predict_y[idx] == 1:
fp += 1
elif test_y[idx] == -1 and predict_y[idx] == -1:
tn += 1
p = tp / (fp + tp)
pf = fp / (fp + tn)
pd = tp / (tp + fn)
F_measure = 2 * pd * p / (pd + p)
""" print('precision:', 100 * p, '%')
print('recall:', 100 * recall_score(test_y, predict_y), '%')
print('pf:', 100 * pf, '%')
print('F-measure:', 100 * F_measure, '%')
print('accuracy:', 100 * accuracy_score(test_y, predict_y), '%')
print('AUC:', 100 * roc_auc_score(test_y, predict_y), '%') """
print('precision:', p)
print('recall:', recall_score(test_y, predict_y))
print('pf:', pf)
print('F-measure:', F_measure)
print('accuracy:', accuracy_score(test_y, predict_y))
print('AUC:', roc_auc_score(test_y, predict_y))
# -*- coding: utf-8 -*- """ http://scikit-learn.org/stable/modules/generated/sklearn.semi_supervised.LabelSpreading.html Created on Fri Sep 14 16:13:06 2018 @author: Akitaka """ import numpy as np from sklearn import datasets from sklearn.semi_supervised import LabelSpreading label_prop_model = LabelSpreading() iris = datasets.load_iris() rng = np.random.RandomState(42) random_unlabeled_points = rng.rand(len(iris.target)) < 0.3 labels = np.copy(iris.target) labels[random_unlabeled_points] = -1 label_prop_model.fit(iris.data, labels) print(labels) print(iris.target) print(label_prop_model.transduction_) print(label_prop_model.predict(iris.data))
4. 1. 6. -1. 4. 4. 1. 1. 6. 6. -1. 4. 4. 4. 3. 2. 6. -1. 1. 6. 4. 4. 4. 5. 6. -1. -1. 5. 2. 6. 1. 6. 3. 2. 6. 3. 3. 1. 2. 5. 2. -1. -1. 1. 6. 6. -1. 6. 6. 6. 4. 6. -1. 2. 3. 2. 5. 4. 4. 6. 4. -1. 4. 2. 6. 1. 1. 2. -1. 5. 2. 4. 3. -1. 6. 2. 5. 2. 2. 5. 5. 4. 2. 1. -1. 1.] (500, 100) (500,) """ from sklearn.semi_supervised import LabelSpreading label_propagation_model = LabelSpreading() label_propagation_model.fit(X, y) # make predictions for first twenty samples (some will be known, some unknown) for i in range(20): print 'y: ', y[i], '\t', 'y_hat: ', label_propagation_model.predict(X[i].reshape(1,-1)) """ y: 6.0 y_hat: [6.] y: 6.0 y_hat: [6.] y: 2.0 y_hat: [2.] y: 1.0 y_hat: [1.] y: -1.0 y_hat: [6.] * y: 2.0 y_hat: [2.] y: 6.0 y_hat: [6.] y: 4.0 y_hat: [4.] y: 3.0 y_hat: [3.] y: 5.0 y_hat: [5.] y: 6.0 y_hat: [6.] y: 4.0 y_hat: [4.] y: 3.0 y_hat: [3.] y: 3.0 y_hat: [3.]
label_prop_model = LabelPropagation(kernel=p_ss_kern,
gamma=p_gamma,
n_neighbors=p_neighbors,
alpha=p_alpha,
max_iter=70)
else:
label_prop_model = dic_ss_mod[p_ss_mod](kernel=p_ss_kern,
gamma=p_gamma,
n_neighbors=p_neighbors)
print('Start to fit. Run for shelter!')
label_prop_model.fit(X_tot, y_tot)
temp_acc = label_prop_model.score(X_valid_lab, y_valid)
print('{} / {} :accuracy = {}'.format(i, p_manyfit, temp_acc))
RESULT_ACC_SS += temp_acc
y_tot = label_prop_model.transduction_
y_submit = label_prop_model.predict(X_submit)
save_to_csv(X_tot, y_tot, X_valid_lab, y_valid)
RESULT_ACC_SS /= p_manyfit
json_dict['ss_accuracy'] = RESULT_ACC_SS
print('accuracy obtained on the test set of the ss algo:', RESULT_ACC_SS)
else:
init_variables()
#PCA preprocessing
if (PCA_MODE):
pca_preprocess()
X_tot, y_tot, X_valid, y_valid = load_xy()
##############################NEURAL NETWORK PART ##################################
if (USING_NN):
model = build_model()
def build_models(trainX, trainY, testX, testY, source_pos, target_pos, window):
#######################
### SEMI-SUPERVISED ###
########################
# Label Propagation
label_prop_model = LabelPropagation(kernel='knn')
label_prop_model.fit(trainX, trainY)
Y_Pred = label_prop_model.predict(testX)
acc_ss_propagation, acc_ss_propagation_INFO = checkAccuracy(testY, Y_Pred)
# Label Spreading
label_prop_models_spr = LabelSpreading(kernel='knn')
label_prop_models_spr.fit(trainX, trainY)
Y_Pred = label_prop_models_spr.predict(testX)
acc_ss_spreading, acc_ss_spreading_INFO = checkAccuracy(testY, Y_Pred)
########################
#### WITHOUT TL ########
########################
# LogisticRegression
modelLR = LogisticRegression()
modelLR.fit(trainX, trainY)
predLR = modelLR.predict(testX)
accLR, acc_LR_INFO = checkAccuracy(testY, predLR)
# DecisionTreeClassifier
modelDT = tree.DecisionTreeClassifier()
modelDT.fit(trainX, trainY)
predDT = modelDT.predict(testX)
accDT, acc_DT_INFO = checkAccuracy(testY, predDT)
# BernoulliNB
modelNB = BernoulliNB()
modelNB.fit(trainX, trainY)
predND = modelNB.predict(testX)
accNB, acc_NB_INFO = checkAccuracy(testY, predND)
#
print("WITHOUT TL ACC_LR:", accLR, " ACC_DT:", accDT, " ACC_NB:", accNB)
########################
#### WITH TL ########
########################
####################################################
### Kernel Mean Matching (Huang et al., 2006)
###
# Decision Tree
print("\n Kernel Mean Matching (Huang et al., 2006) ")
classifier = ImportanceWeightedClassifier(iwe='kmm', loss="dtree")
classifier.fit(trainX, trainY, testX)
pred_naive = classifier.predict(testX)
acc_DT_KMM, acc_DT_KMM_INFO = checkAccuracy(testY, pred_naive)
print("ACC:", acc_DT_KMM)
# Logistic Regression
classifier = ImportanceWeightedClassifier(iwe='kmm', loss="logistic")
classifier.fit(trainX, trainY, testX)
pred_naive = classifier.predict(testX)
acc_LR_KMM, acc_LR_KMM_INFO = checkAccuracy(testY, pred_naive)
print("ACC:", acc_LR_KMM)
# Naive Bayes Bernoulli
classifier = ImportanceWeightedClassifier(iwe='kmm', loss="berno")
classifier.fit(trainX, trainY, testX)
pred_naive = classifier.predict(testX)
acc_NB_KMM, acc_NB_KMM_INFO = checkAccuracy(testY, pred_naive)
print("ACC:", acc_NB_KMM)
####################################################
### Nearest-neighbour-based weighting (Loog, 2015)
###
# Decision Tree
print("\n Nearest-neighbour-based weighting (Loog, 2015) ")
classifier = ImportanceWeightedClassifier(iwe='nn', loss="dtree")
classifier.fit(trainX, trainY, testX)
pred_naive = classifier.predict(testX)
acc_DT_NN, acc_DT_NN_INFO = checkAccuracy(testY, pred_naive)
print("ACC:", acc_DT_NN)
# Logistic Regression
print("\n Nearest-neighbour-based weighting (Loog, 2015) ")
classifier = ImportanceWeightedClassifier(iwe='nn', loss="logistic")
classifier.fit(trainX, trainY, testX)
pred_naive = classifier.predict(testX)
acc_LR_NN, acc_LR_NN_INFO = checkAccuracy(testY, pred_naive)
print("ACC:", acc_LR_NN)
# Naive Bayes Bernoulli
print("\n Nearest-neighbour-based weighting (Loog, 2015) ")
classifier = ImportanceWeightedClassifier(iwe='nn', loss="berno")
classifier.fit(trainX, trainY, testX)
pred_naive = classifier.predict(testX)
acc_NB_NN, acc_NB_NN_INFO = checkAccuracy(testY, pred_naive)
print("ACC:", acc_NB_NN)
####################################################
### Transfer Component Analysis (Pan et al, 2009)
###
# Decision Tree
print("\n Transfer Component Analysis (Pan et al, 2009)")
classifier = TransferComponentClassifier(loss="dtree", num_components=6)
classifier.fit(trainX, trainY, testX)
pred_naive = classifier.predict(testX)
acc_DT_TCA, acc_DT_TCA_INFO = checkAccuracy(testY, pred_naive)
print("ACC:", acc_DT_TCA)
# Logistic Regression
classifier = TransferComponentClassifier(loss="logistic", num_components=6)
classifier.fit(trainX, trainY, testX)
pred_naive = classifier.predict(testX)
acc_LR_TCA, acc_LR_TCA_INFO = checkAccuracy(testY, pred_naive)
print("ACC:", acc_LR_TCA)
# Naive Bayes Bernoulli
classifier = TransferComponentClassifier(loss="berno", num_components=6)
classifier.fit(trainX, trainY, testX)
pred_naive = classifier.predict(testX)
acc_NB_TCA, acc_NB_TCA_INFO = checkAccuracy(testY, pred_naive)
print("ACC:", acc_NB_TCA)
####################################################
### Subspace Alignment (Fernando et al., 2013)
###
# Decision Tree
print("\n Subspace Alignment (Fernando et al., 2013) ")
classifier = SubspaceAlignedClassifier(loss="dtree")
classifier.fit(trainX, trainY, testX)
pred_naive = classifier.predict(testX)
acc_DT_SA, acc_DT_SA_INFO = checkAccuracy(testY, pred_naive)
print("ACC:", acc_DT_SA)
# Logistic Regression
print("\n Subspace Alignment (Fernando et al., 2013) ")
classifier = SubspaceAlignedClassifier(loss="logistic")
classifier.fit(trainX, trainY, testX)
pred_naive = classifier.predict(testX)
acc_LR_SA, acc_LR_SA_INFO = checkAccuracy(testY, pred_naive)
print("ACC:", acc_LR_SA)
# Naive Bayes Bernoulli
print("\n Subspace Alignment (Fernando et al., 2013) ")
classifier = SubspaceAlignedClassifier(loss="berno")
classifier.fit(trainX, trainY, testX)
pred_naive = classifier.predict(testX)
acc_NB_SA, acc_NB_SA_INFO = checkAccuracy(testY, pred_naive)
print("ACC:", acc_NB_SA)
#################################
############# ENSEMBLE ##########
#################################
classifier_SA_DT = SubspaceAlignedClassifier(loss="dtree")
classifier_SA_LR = SubspaceAlignedClassifier(loss="logistic")
classifier_SA_NB = SubspaceAlignedClassifier(loss="berno")
classifier_TCA_DT = TransferComponentClassifier(loss="dtree")
classifier_TCA_LR = TransferComponentClassifier(loss="logistic")
classifier_TCA_NB = TransferComponentClassifier(loss="berno")
classifier_NN_DT = ImportanceWeightedClassifier(iwe='nn', loss="dtree")
classifier_NN_LR = ImportanceWeightedClassifier(iwe='nn', loss="logistic")
classifier_NN_NB = ImportanceWeightedClassifier(iwe='nn', loss="berno")
classifier_KMM_DT = ImportanceWeightedClassifier(iwe='kmm', loss="dtree")
classifier_KMM_LR = ImportanceWeightedClassifier(iwe='kmm',
loss="logistic")
classifier_KMM_NB = ImportanceWeightedClassifier(iwe='kmm', loss="berno")
#
eclf = EnsembleClassifier(
clfs=[classifier_TCA_DT, classifier_NN_DT, classifier_KMM_DT])
eclf.fit(trainX, trainY, testX)
pred = eclf.predict_v2(testX)
acc_ENSEMBLE, acc_ENSEMBLE_INFO = checkAccuracy(testY, pred)
########################
#### RETURN ########
########################
return pd.DataFrame([{
'window': window,
'source_position': source_pos,
'target_position': target_pos,
'acc_SS_propagation': acc_ss_propagation,
'acc_SS_propagation_INFO': acc_ss_propagation_INFO,
'acc_SS_spreading': acc_ss_spreading,
'acc_SS_spreading_INFO': acc_ss_spreading_INFO,
'acc_ENSEMBLE': acc_ENSEMBLE,
'acc_LR': accLR,
'acc_LR_INFO': str(acc_LR_INFO),
'acc_DT': accDT,
'acc_DT_INFO': str(acc_DT_INFO),
'acc_NB': accNB,
'acc_NB_INFO': str(acc_NB_INFO),
'acc_LR_KMM': acc_LR_KMM,
'acc_LR_KMM_INFO': str(acc_LR_KMM_INFO),
'acc_LR_NN': acc_LR_NN,
'acc_LR_NN_INFO': str(acc_LR_NN_INFO),
'acc_LR_TCA': acc_LR_TCA,
'acc_LR_TCA_INFO': str(acc_LR_TCA_INFO),
'acc_LR_SA': acc_LR_SA,
'acc_LR_SA_INFO': str(acc_LR_SA_INFO),
'acc_DT_KMM': acc_DT_KMM,
'acc_DT_KMM_INFO': str(acc_DT_KMM_INFO),
'acc_DT_NN': acc_DT_NN,
'acc_DT_NN_INFO': str(acc_DT_NN_INFO),
'acc_DT_TCA': acc_DT_TCA,
'acc_DT_TCA_INFO': str(acc_DT_TCA_INFO),
'acc_DT_SA': acc_DT_SA,
'acc_DT_SA_INFO': str(acc_DT_SA_INFO),
'acc_NB_KMM': acc_NB_KMM,
'acc_NB_KMM_INFO': str(acc_NB_KMM_INFO),
'acc_NB_NN': acc_NB_NN,
'acc_NB_NN_INFO': str(acc_NB_NN_INFO),
'acc_NB_TCA': acc_NB_TCA,
'acc_NB_TCA_INFO': str(acc_NB_TCA_INFO),
'acc_NB_SA': acc_NB_SA,
'acc_NB_SA_INFO': str(acc_NB_SA_INFO)
}])
# 留部分测试数据
x_train, x_test, y_train, y_test = train_test_split(X,
y,
test_size=0.2,
random_state=20)
# 生成有未标记样本的数据集
rng = np.random.RandomState(0)
random_unlabeled = rng.rand(len(y_train)) < 0.8
# 未标记样本的标签设置为-1
y_train[random_unlabeled] = -1
# 调参gamma
# for i in [0.005, 0.01, 0.1, 0.5, 1]:
# model = LabelPropagation(kernel='rbf', gamma=i)
# model.fit(x_train, y_train)
# print(i, accuracy_score(y_test, model.predict(x_test)))
model = LabelSpreading(kernel='rbf', gamma=0.01)
# model = LabelPropagation(kernel='rbf', gamma=0.01)
model.fit(x_train, y_train)
print('===========y===============')
print(y_test)
print('===========y_pred===============')
y_pred = model.predict(x_test)
print(y_pred)
print('=======confusion_matrix=======')
print(confusion_matrix(y_test, y_pred))
print('accuracy: {}'.format(accuracy_score(y_test, y_pred)))
print(model.label_distributions_)
def labelspread(train_data, semi_data, train_label, semi_label, train_name,
semi_name, lib, libname):
print("===========================")
train_d = []
train_l = []
semi_d = []
semi_l = []
name = []
for i in range(len(train_data)):
if train_label[i] in lib:
train_d.append(train_data[i])
train_l.append(train_label[i])
name.append(train_name[i])
for i in range(len(semi_data)):
if semi_label[i] in lib:
semi_d.append(semi_data[i])
semi_l.append(semi_label[i])
name.append(semi_name[i])
train_d = np.array(train_d) / -80.
train_l = np.array(train_l)
semi_d = np.array(semi_d) / -80.
semi_l = np.array(semi_l)
name = np.array(name)
print(libname, ' all num: ', train_d.shape[0] + semi_d.shape[0])
print(libname, ' train num: ', train_d.shape[0])
print(libname, ' ratio: ',
train_d.shape[0] / (train_d.shape[0] + semi_d.shape[0]))
#print('PCA...')
#data = PCA(n_components=439,whiten=True,svd_solver="full",random_state=0).fit_transform(data)
#semi_sp_data = SVD.transform(semi_sp_data)
#print('data PCA size: ',data.shape)
semi_unl = np.full(semi_l.shape[0], -1)
label = np.concatenate((train_l, semi_unl), axis=0).astype('int')
data = np.concatenate((train_d, semi_d), axis=0).astype('float')
print('label size: ', label.shape)
print('data size: ', data.shape)
print('label propagation...')
#print(label)
#model = LabelPropagation(kernel='knn',n_neighbors=5,max_iter=10000,tol=0.001,n_jobs=-1)
model = LabelSpreading(kernel='rbf',
gamma=20,
alpha=0.2,
n_neighbors=5,
max_iter=100000,
tol=0.001,
n_jobs=20)
model.fit(data, label)
oursemi_l = model.predict(semi_d)
ourlabel = np.concatenate((train_l, oursemi_l), axis=0)
csvlabel = np.concatenate((train_l, semi_l), axis=0)
print('our... ', ourlabel)
print('csv... ', csvlabel)
similarity = 0
for i in range(len(ourlabel)):
if ourlabel[i] == csvlabel[i]:
similarity += 1
print('new train num: ', similarity)
print('ratio: ', similarity / len(ourlabel))
return data, name, ourlabel, csvlabel
test_labels = np.argmax(test_labels_one_hot, 1)
x_all = np.concatenate(
(train_data, test_data
)) # concatenate the train and test data (for structure exploitation)
test_labels_none = -1 * np.ones([
test_labels.shape[0],
]) # the label of the test_data is set to -1
y_all = np.concatenate(
(train_labels,
test_labels_none)) # concatenate the train labels and -1 test labels
consist_model = LabelSpreading(gamma=4, max_iter=60)
consist_model.fit(x_all, y_all)
clf.evaluate_sub('consistency model', test_labels,
consist_model.predict(test_data))
lgr_model = clf.classifier('LGR', train_data, train_labels)
clf.evaluate('LGR', lgr_model, test_data, test_labels)
knn_model = clf.classifier('KNN', train_data, train_labels)
clf.evaluate('KNN', knn_model, test_data, test_labels)
bnb_model = clf.classifier('BNB', train_data, train_labels)
clf.evaluate('BNB', bnb_model, test_data, test_labels)
svm_model = clf.classifier('SVM', train_data, train_labels)
clf.evaluate('SVM', svm_model, test_data, test_labels)
dtc_model = clf.classifier('DTC', train_data, train_labels)
clf.evaluate('DTC', dtc_model, test_data, test_labels)
def fit_with_clustering(self, X_l, y_l, X_u, y_u=None):
"""
Initialize the parameter using both labeled and unlabeled data.
The classes of unlabeled data are assigned using similarity with labeled data.
Assume unlabeled class as missing values, apply EM on unlabeled data to refine classifier.
The label propagation can only use dense matrix, so it is quite time consuming.
"""
n_ul_docs = X_u.shape[0] # number of unlabeled samples
n_l_docs = X_l.shape[0] # number of labeled samples
# initialization (n_docs = n_ul_docs):
# assign class to unlabeled data using similarity with labeled data if y_u is not given
if (y_u == None):
label_prop_model = LabelSpreading(kernel='rbf',
max_iter=5,
n_jobs=-1)
y_u = np.array([-1.0] * n_ul_docs)
X = vstack([X_l, X_u])
y = np.concatenate((y_l, y_u), axis=0)
label_prop_model.fit(X.toarray(), y)
y_u = label_prop_model.predict(X_u.toarray())
y = np.concatenate((y_l, y_u), axis=0)
clf = deepcopy(self.clf) # build new copy of classifier
clf.fit(X,
y) # use labeled data only to initialize classifier parameters
prev_log_lkh = self.log_lkh # record log likelihood of previous EM iteration
lp_w_c = clf.feature_log_prob_ # log CP of word given class [n_classes, n_words]
b_w_d = (X_u > 0) # words in each document [n_docs, n_words]
lp_d_c = get_blas_funcs(
"gemm", [lp_w_c, b_w_d.T.toarray()
]) # log CP of doc given class [n_classes, n_docs]
lp_d_c = lp_d_c(alpha=1.0, a=lp_w_c, b=b_w_d.T.toarray())
lp_c = np.matrix(
clf.class_log_prior_).T # log prob of classes [n_classes, 1]
lp_c = np.repeat(lp_c, n_ul_docs,
axis=1) # repeat for each doc [n_classes, n_docs]
lp_dc = lp_d_c + lp_c # joint prob of doc and class [n_classes, n_docs]
p_c_d = clf.predict_proba(
X_u) # weight of each class in each doc [n_docs, n_classes]
expectation = get_blas_funcs(
"gemm",
[p_c_d, lp_dc
]) # expectation of log likelihood over all unlabeled docs
expectation = expectation(alpha=1.0, a=p_c_d, b=lp_dc).trace()
self.clf = deepcopy(clf)
self.log_lkh = expectation
if self.print_log_lkh:
print("Initial expected log likelihood = %0.3f\n" % expectation)
# Loop until log likelihood does not improve
iter_count = 0 # count EM iteration
while (self.log_lkh - prev_log_lkh >= self.tol
and iter_count < self.max_iter):
# while (iter_count<self.max_iter):
iter_count += 1
if self.print_log_lkh:
print("EM iteration #%d" % iter_count) # debug
# E-step: Estimate class membership of unlabeled documents
y_u = clf.predict(X_u)
# M-step: Re-estimate classifier parameters
X = vstack([X_l, X_u])
y = np.concatenate((y_l, y_u), axis=0)
clf.fit(X, y)
# check convergence: update log likelihood
p_c_d = clf.predict_proba(X_u)
lp_w_c = clf.feature_log_prob_ # log CP of word given class [n_classes, n_words]
b_w_d = (X_u > 0) # words in each document
lp_d_c = get_blas_funcs(
"gemm", [lp_w_c, b_w_d.transpose().toarray()
]) # log CP of doc given class [n_classes, n_docs]
lp_d_c = lp_d_c(alpha=1.0, a=lp_w_c, b=b_w_d.transpose().toarray())
lp_c = np.matrix(
clf.class_log_prior_).T # log prob of classes [n_classes, 1]
lp_c = np.repeat(lp_c, n_ul_docs,
axis=1) # repeat for each doc [n_classes, n_docs]
lp_dc = lp_d_c + lp_c # joint prob of doc and class [n_classes, n_docs]
expectation = get_blas_funcs(
"gemm",
[p_c_d, lp_dc
]) # expectation of log likelihood over all unlabeled docs
expectation = expectation(alpha=1.0, a=p_c_d, b=lp_dc).trace()
if self.print_log_lkh:
print("\tExpected log likelihood = %0.3f" % expectation)
if (expectation - self.log_lkh >= self.tol):
prev_log_lkh = self.log_lkh
self.log_lkh = expectation
self.clf = deepcopy(clf)
else:
break
self.feature_log_prob_ = self.clf.feature_log_prob_
self.coef_ = self.clf.coef_
return self
# training the scaler
scaler = StandardScaler(with_mean=True, with_std=True)
scaler = scaler.fit(x_train_labeled)
# scaling the training and test data
x_train_labeled_scaled = scaler.transform(x_train_labeled)
# x_test_scaled = scaler.transform(x_test)
# stratified ten fold cross validation
cv = StratifiedKFold(n_splits=10, shuffle=False, random_state=seed)
# setup the model
for train_index, val_index in cv.split(x_train_labeled_scaled, y_train_labeled):
# create training and validation splits
x_train, x_val = x_train_labeled_scaled[train_index], x_train_labeled_scaled[val_index]
y_train, y_val = y_train_labeled[train_index], y_train_labeled[val_index]
# my_kernel = polynomial_kernel(x_train, y_train, degree=5, gamma=None, coef0=1)
# create model and fit data
model = LabelSpreading(kernel=polynomial_kernel, gamma=20, alpha=0.2, max_iter=1, tol=0.001, n_jobs=1)
model = model.fit(x_train, y_train)
# evaluate model
y_pred = model.predict(x_val)
acc = accuracy_score(y_val, y_pred)
print("Model Result: Split {} - Acc: {}".format(train_index, acc))
test_svm(x_all, y_all)
# make a more select dataset
# Filter the rest of the data
x_obs, y_obs, x_nuls = load_data()
keep = list(best.k_feature_idx_)
np.save('sfs_features', keep)
# keep = np.load('sfs_features.npy')
x_obs = x_obs[:, keep]
x_nuls = x_nuls[:, keep]
# apply LabelSpreading
label_spread = LabelSpreading(kernel='knn', alpha=0.8)
label_spread.fit(x_obs, y_obs)
x_all = np.concatenate([x_obs, x_nuls], axis=0)
y_all = np.concatenate([y_obs, label_spread.predict(x_nuls)], axis=0)
x, y = shuffle(x_all, y_all, random_state=42)
smpnum = min([sum(y == i) for i in range(1, 6)])
y_btr = y[y == 1][:smpnum]
x_btr = x[y == 1][:smpnum]
for i in range(2, 6):
x_btr = np.concatenate([x_btr, x[y == i][:smpnum]])
y_btr = np.concatenate([y_btr, y[y == i][:smpnum]])
x_tr, x_te, y_tr, y_te = train_test_split(x_btr, y_btr, test_size=0.20)
mod = svm.SVC(kernel='rbf')
mod.fit(x_tr, y_tr)
mod.score(x_te, y_te)
nb_samples = 5000
nb_unlabeled = 1000
if __name__ == '__main__':
# Create the dataset
X, Y = make_classification(n_samples=nb_samples, n_features=2, n_informative=2, n_redundant=0, random_state=100)
Y[nb_samples - nb_unlabeled:nb_samples] = -1
# Create and fit a LabelSpreading instance
ls = LabelSpreading(kernel='rbf', gamma=10.0, alpha=0.2)
ls.fit(X, Y)
Y_final = ls.predict(X)
# Show the final result
fig, ax = plt.subplots(1, 2, figsize=(18, 8))
ax[0].scatter(X[Y == 0, 0], X[Y == 0, 1], color='#88d7f0', marker='s', s=100)
ax[0].scatter(X[Y == 1, 0], X[Y == 1, 1], color='#55ffec', marker='o', s=100)
ax[0].scatter(X[Y == -1, 0], X[Y == -1, 1], color='r', marker='x', s=20)
ax[0].set_xlabel(r'$x_0$')
ax[0].set_ylabel(r'$x_1$')
ax[0].set_title('Dataset')
ax[0].grid()
ax[1].scatter(X[Y_final == 0, 0], X[Y_final == 0, 1], color='#88d7f0', marker='s', s=100)
ax[1].scatter(X[Y_final == 1, 0], X[Y_final == 1, 1], color='#55ffec', marker='o', s=100)
hist, bins = np.histogram(
lables,
bins=[-0.1, 0.1, 1.1, 2.1, 3.1, 4.1, 5.1, 6.1, 7.1, 8.1, 9.1, 10.1])
print(hist)
print(bins)
print(train_labeled.shape)
print(train_labeled[:, 0])
train_unlabeled = sklearn.preprocessing.scale(train_unlabeled)
features = sklearn.preprocessing.scale(features)
lp = LabelSpreading(kernel='knn',
gamma=20,
n_neighbors=7,
alpha=0.2,
max_iter=50,
tol=0.01,
n_jobs=-1)
y = lables
for i in range(21000):
y = np.concatenate((y, np.array([-1])), axis=0)
all_data = np.concatenate((features, train_unlabeled), axis=0)
lp.fit(all_data, y)
Yresult = lp.predict(all_data)
print(lp.score(all_data, Yresult))
np.savetxt('semiLabelsOfUnlabeled2.csv', Yresult, delimiter=",")
print cutdown_labels ''' [ 0 0 0 0 -1 -1 -1 0 0 0 -1 0 0 -1 -1 -1 0 0 0 -1 0 -1 -1 0 0 0 -1 0 0 -1 0 -1 -1 0 0 0 0 -1 0 0 -1 0 -1 0 -1 0 0 0 0 -1 1 1 1 1 1 1 -1 -1 -1 1 1 -1 1 1 -1 1 -1 1 -1 1 1 -1 -1 1 1 1 1 -1 1 -1 1 1 1 -1 1 1 1 1 1 1 -1 1 1 1 1 1 1 1 -1 -1 -1 2 2 2 2 -1 2 2 -1 -1 -1 -1 2 2 2 2 2 -1 2 2 2 2 2 -1 -1 2 2 2 -1 2 2 -1 -1 2 2 2 2 2 2 2 2 -1 2 2 -1 -1 2 2 -1 -1] ''' # fit LabelSpreading model label_propagation_model.fit(iris['data'], cutdown_labels) # quick test print 'y: ', full_labels[-1] print 'y_hat: ', label_propagation_model.predict(iris['data'][-1]) ''' y: 2 y_hat: [2] ''' # overall accuracy correct = 0.0 for i in range(len(iris['data'])): if label_propagation_model.predict(iris['data'][i])[0] == full_labels[i]: correct += 1 print 'Overall accuracy: ', correct/ len(iris['data']) ''' Overall accuracy: 0.98
y = np.asarray(Y_train)
for i in idxs:
y[i] = -1
Y_train = y
# Train model and print statistics (use 'knn' as kernel)
from sklearn.semi_supervised import LabelSpreading
model = LabelSpreading(kernel = 'knn', n_neighbors = 10, max_iter=1000).fit(X_train, Y_train)
print("Percentage of correct predictions = {}".format(round(100*model.score(X_test, Y_test),2)))
pred = model.predict(X_test) == Y_test
print("Correct: {}".format(np.count_nonzero(pred==True)),"/",
"Incorrect: {}".format(np.count_nonzero(pred==False)))
Z1 = model.predict(X_test).reshape(Y_test.size,1)
Z2 = np.asarray(Y_test).reshape(Y_test.size,1)
Z3 = np.around(model.predict_proba(X_test),decimals=2)
data = np.concatenate((Z1,Z2,Z3),axis=1)
outcome = pd.DataFrame(data, columns = ["Predicted Label",
"Actual Label",
"Prob. Label = 0.0",
"Prob. Label = 1.0"])
indicesToKeep = outcome["Predicted Label"] != outcome["Actual Label"]
print("False predictions with associated class probabilities:\n{}".format(outcome[indicesToKeep]))
server.sendmail("*****@*****.**", "*****@*****.**", msg)
server.quit()
# In[15]:
targets
# # Measuring effectiveness.
#
#
# In[26]:
from sklearn.metrics import precision_score, accuracy_score, f1_score, recall_score
t_pred = label_prop_model.predict(x_test)
print("Metrics based on 50 hold-out points")
print("Macro")
print("accuracy: %f" % accuracy_score(t_test, t_pred))
print("precision: %f" % precision_score(t_test, t_pred, average='macro'))
print("recall: %f" % recall_score(t_test, t_pred, average='macro'))
print("f1: %f" % f1_score(t_test, t_pred, average='macro'))
print("\n\nMicro")
print("accuracy: %f" % accuracy_score(t_test, t_pred))
print("precision: %f" % precision_score(t_test, t_pred, average='micro'))
print("recall: %f" % recall_score(t_test, t_pred, average='micro'))
print("f1: %f" % f1_score(t_test, t_pred, average='micro'))
from sklearn import metrics
def main(argv):
trainFile = None
testFile = None
outFile = None
try:
opts, args = getopt.getopt(argv, "hi:t:o:")
except getopt.GetoptError:
usage()
sys.exit(2)
for opt, arg in opts:
if opt == '-h':
usage()
sys.exit()
elif opt == '-i':
trainFile = arg
elif opt == '-t':
testFile = arg
elif opt == '-o':
outFile = arg
else:
usage()
print('Invalid argument %s' % opt)
sys.exit(2)
if (None == trainFile) or (None == testFile) or (None == outFile):
print("Missing arguments")
usage()
sys.exit(2)
facialData = pd.read_csv(trainFile)
testData = pd.read_csv(testFile)
testData.drop(columns=['id'], inplace=True)
testData.reset_index(inplace=True, drop=True)
labels = testData['class']
classLabels = []
for i in range(len(labels)):
classLabels.append(1 if (labels[i] == 'deceptive') else 0)
testData.drop(columns=['class'], inplace=True)
X_train, X_test, y_train, y_test = train_test_split(testData,
classLabels,
test_size=0.2,
stratify=classLabels,
random_state=42)
X_train.insert(1, "class", y_train)
sns.countplot(x="class", data=X_train)
X_train = X_train.drop(columns=['class'])
# Label Propagation
modelLabelProp = LabelPropagation()
labels = [-1] * len(facialData[:10000])
labels.extend(y_train)
inputData = pd.concat([facialData[:10000], X_train],
sort=False,
ignore_index=True,
copy=False)
modelLabelProp.fit(inputData, labels)
yPred = modelLabelProp.predict(X_test)
print("LABEL PROPAGATION:")
metricNPlot(modelLabelProp, X_test, y_test, yPred)
with open(outFile, 'w') as f:
f.write("Label Propagation prediction\n")
for item in yPred:
f.write("%s\n" % item)
# Label Spreading
modelLabelSpread = LabelSpreading(kernel='knn', n_neighbors=15)
labels = [-1] * len(facialData[:10000])
labels.extend(y_train)
inputData = pd.concat([facialData[:10000], X_train],
sort=False,
ignore_index=True,
copy=False)
modelLabelSpread.fit(inputData, labels)
yPred = modelLabelSpread.predict(X_test)
print("LABEL SPREADING:")
metricNPlot(modelLabelSpread, X_test, y_test, yPred)
with open(outFile, 'a') as f:
f.write("Label Spreading prediction\n")
for item in yPred:
f.write("%s\n" % item)
height = [0.8, 0.68]
bars = ('Label Propagation', 'Label Spreading')
y_pos = np.arange(len(bars))
plt.title("Performance Comparison")
plt.bar(y_pos, height, color=['cyan', 'red'])
plt.xticks(y_pos, bars)
plt.show()
def __call__(self, *args, **kwargs):
""" Augment the labels
Inputs:
tr_percs: percentage of splitting between labeled and unlabeled observations
algs: methods to perform the label propagation
max_iter: parameter for 'gtg': number of iterations
"""
tr_percs = kwargs.pop('tr_percs', [0.02, 0.05, 0.1])
algs = kwargs.pop('algs', ['gtg', 'svm', 'labels_only'])
max_iter = kwargs.pop('max_iter', 25)
if not osp.exists(self.label_dir):
os.makedirs(self.label_dir)
with open(osp.join(self.label_dir, 'test_labels.txt'), 'w') as dst:
loader = prepare_loader(
osp.join(self.splitting_dir, 'test.txt'),
img_root=self.dset['src'],
stats=self.dset['stats'],
batch_size=1,
shuffle=False,
)
for _, label, path in loader:
dst.write(osp.join(path[0] + ',' + str(label.item()) + '\n'))
for net_name in self.net_names:
with open(osp.join(self.feat_dir, 'train', net_name + '.pickle'),
'rb') as pkl:
net_name, labels, features, fnames = pickle.load(pkl)
labels = labels.ravel()
# uncomment to debug code
# labels = labels[:5000]
# features = features[:5000]
# fnames = fnames[:5000]
for tr_perc in tr_percs:
labeled, unlabeled = equiclass_mapping(labels, tr_perc)
for alg in algs:
print(net_name + ' - ' + str(self.dset['nr_classes']) +
' classes')
# generate alg label file name
alg_path = osp.join(self.label_dir, alg, net_name,
'labels_{}.txt'.format(tr_perc))
if self.hard_labels:
alg_labels = np.full(labels.shape[0], -1)
alg_labels[labeled] = labels[labeled]
else:
alg_labels = np.zeros(
(len(labels), self.dset['nr_classes']))
alg_labels[labeled,
labels[labeled].ravel().astype(int)] = 1.0
if alg == 'gtg':
# predict labels with gtg
if 'W' not in locals():
W = gtg.sim_mat(features, verbose=True)
ps = init_rand_probability(labels, labeled, unlabeled)
res = gtg.gtg(W,
ps,
max_iter=max_iter,
labels=labels,
U=unlabeled,
L=labeled)
if self.hard_labels:
alg_labels[unlabeled] = res[unlabeled].argmax(
axis=1)
else:
alg_labels[unlabeled] = res[unlabeled]
elif alg == 'svm':
# predict labels with a linear SVM
lin_svm = svm.LinearSVC()
if self.hard_labels:
lin_svm.fit(features[labeled, :], labels[labeled])
svm_labels = lin_svm.predict(
features[unlabeled]).astype(int)
else:
cv = min(
np.unique(labels[labeled],
return_counts=True)[1].min(), 3)
clf = CalibratedClassifierCV(lin_svm, cv=cv)
clf.fit(features[labeled, :], labels[labeled])
svm_labels = clf.predict_proba(features[unlabeled])
alg_labels[unlabeled] = svm_labels
elif alg == 'label_propagation':
# predict labels with a label propagation model
label_propagation = LabelPropagation(kernel='rbf',
gamma=0.05,
max_iter=4000)
labels[unlabeled] = -1
label_propagation.fit(features, labels)
if self.hard_labels:
label_propagation_labels = label_propagation.predict(
features[unlabeled]).astype(int)
else:
label_propagation_labels = label_propagation.predict_proba(
features[unlabeled])
alg_labels[unlabeled] = label_propagation_labels
elif alg == 'label_spreading':
# predict labels with a label propagation model
label_spreading = LabelSpreading(kernel='rbf',
gamma=0.05)
labels[unlabeled] = -1
label_spreading.fit(features, labels)
if self.hard_labels:
label_spreading_labels = label_spreading.predict(
features[unlabeled]).astype(int)
else:
label_spreading_labels = label_spreading.predict_proba(
features[unlabeled])
alg_labels[unlabeled] = label_spreading_labels
elif alg == 'harmonic':
if 'W' not in locals():
W = gtg.sim_mat(features, verbose=True)
soft_labels, hard_labels = harmonic_function(
W, labels, labeled, unlabeled)
if self.hard_labels:
label_harmonic = hard_labels
else:
label_harmonic = soft_labels
alg_labels[unlabeled] = label_harmonic
elif alg == 'labels_only':
# generate labeled only file
alg_labels = alg_labels[labeled]
if not osp.exists(osp.dirname(alg_path)):
os.makedirs(osp.dirname(alg_path))
if (self.hard_labels and (alg_labels == -1).sum() > 0) or \
(not self.hard_labels and (alg_labels.sum(axis=1) == 0.).sum() > 0):
raise ValueError(
'There is some unlabeled observation, check \''
+ alg + '\' algorithm,')
create_relabeled_file([fnames[i] for i in labeled],
alg_path,
alg_labels,
sep=',')
break
else:
raise ValueError('algorithm \'' + alg +
'\' not recognized.')
if not osp.exists(osp.dirname(alg_path)):
os.makedirs(osp.dirname(alg_path))
if (self.hard_labels and (alg_labels == -1).sum() > 0) or\
(not self.hard_labels and (alg_labels.sum(axis=1) == 0.).sum() > 0):
raise ValueError('There is some unlabeled observation,'
'check \'' + alg + '\' algorithm,')
create_relabeled_file(fnames,
alg_path,
alg_labels,
sep=',')
if 'W' in locals():
del W
