def merit_calculation(X, y):
"""
This function calculates the merit of X given class labels y, where
merits = (k * rcf)/sqrt(k+k*(k-1)*rff)
rcf = (1/k)*sum(su(fi,y)) for all fi in X
rff = (1/(k*(k-1)))*sum(su(fi,fj)) for all fi and fj in X
Input
----------
X: {numpy array}, shape (n_samples, n_features)
input data
y: {numpy array}, shape (n_samples,)
input class labels
Output
----------
merits: {float}
merit of a feature subset X
"""
n_samples, n_features = X.shape
rff = 0
rcf = 0
for i in range(n_features):
fi = X[:, i]
rcf += su_calculation(fi, y)
for j in range(n_features):
if j > i:
fj = X[:, j]
rff += su_calculation(fi, fj)
rff *= 2
merits = rcf / np.sqrt(n_features + rff)
return merits
def fcbf(X, y, **kwargs):
"""
This function implements Fast Correlation Based Filter algorithm
Input
-----
X: {numpy array}, shape (n_samples, n_features)
input data, guaranteed to be discrete
y: {numpy array}, shape (n_samples,)
input class labels
kwargs: {dictionary}
delta: {float}
delta is a threshold parameter, the default value of delta is 0
Output
------
F: {numpy array}, shape (n_features,)
index of selected features, F[1] is the most important feature
Reference
---------
Yu, Lei and Liu, Huan. "Feature Selection for High-Dimensional Data: A Fast Correlation-Based Filter Solution." ICML 2003.
"""
n_samples, n_features = X.shape
if 'delta' in kwargs.keys():
delta = kwargs['delta']
else:
# the default value of delta is 0
delta = 0
# t1[:,0] stores index of features, t1[:,1] stores symmetrical uncertainty of features
t1 = np.zeros((n_features, 2))
for i in range(n_features):
f = X[:, i]
t1[i, 0] = i
t1[i, 1] = su_calculation(f, y)
s_list = t1[t1[:, 1] > delta, :]
# index of selected features, initialized to be empty
F = []
while len(s_list) != 0:
# select the largest su inside s_list
idx = np.argmax(s_list[:, 1])
# record the index of the feature with the largest su
fp = X[:, int(s_list[idx, 0])]
np.delete(s_list, idx, 0)
F.append(s_list[idx, 0])
for i in s_list[:, 0]:
i = int(i)
fi = X[:, i]
if su_calculation(fp, fi) >= t1[i, 1]:
# construct the mask for feature whose su is larger than su(fp,y)
idx = s_list[:, 0] != i
idx = np.array([idx, idx])
idx = np.transpose(idx)
# delete the feature by using the mask
s_list = s_list[idx]
length = len(s_list) / 2
s_list = s_list.reshape((length, 2))
return np.array(F, dtype=int)
def merit_calculation(X, y):
"""
This function calculates the merit of X given class labels y, where
merits = (k * rcf)/sqrt(k+k*(k-1)*rff)
rcf = (1/k)*sum(su(fi,y)) for all fi in X
rff = (1/(k*(k-1)))*sum(su(fi,fj)) for all fi and fj in X
Input
----------
X: {numpy array}, shape (n_samples, n_features)
input data
y: {numpy array}, shape (n_samples,)
input class labels
Output
----------
merits: {float}
merit of a feature subset X
"""
n_samples, n_features = X.shape
rff = 0
rcf = 0
for i in range(n_features):
fi = X[:, i]
rcf += su_calculation(fi, y)
for j in range(n_features):
if j > i:
fj = X[:, j]
rff += su_calculation(fi, fj)
rff *= 2
merits = rcf / np.sqrt(n_features + rff)
return merits
def fcbf(X, y, **kwargs):
"""
This function implements Fast Correlation Based Filter algorithm
Input
-----
X: {numpy array}, shape (n_samples, n_features)
input data, guaranteed to be discrete
y: {numpy array}, shape (n_samples,)
input class labels
kwargs: {dictionary}
delta: {float}
delta is a threshold parameter, the default value of delta is 0
Output
------
F: {numpy array}, shape (n_features,)
index of selected features, F[0] is the most important feature
Reference
---------
Yu, Lei and Liu, Huan. "Feature Selection for High-Dimensional Data: A Fast Correlation-Based Filter Solution." ICML 2003.
"""
n_samples, n_features = X.shape
if 'delta' in kwargs.keys():
delta = kwargs['delta']
else:
# the default value of delta is 0
delta = 0
# t1[:,0] stores index of features, t1[:,1] stores symmetrical uncertainty of features
t1 = np.zeros((n_features, 2))
for i in range(n_features):
f = X[:, i]
t1[i, 0] = i
t1[i, 1] = su_calculation(f, y)
s_list = t1[t1[:, 1] > delta, :]
# index of selected features, initialized to be empty
F = []
while len(s_list) != 0:
# select the largest su inside s_list
idx = np.argmax(s_list[:, 1])
# record the index of the feature with the largest su
fp = X[:, s_list[idx, 0]]
np.delete(s_list, idx, 0)
F.append(s_list[idx, 0])
for i in s_list[:, 0]:
fi = X[:, i]
if su_calculation(fp, fi) >= t1[i, 1]:
# construct the mask for feature whose su is larger than su(fp,y)
idx = s_list[:, 0] != i
idx = np.array([idx, idx])
idx = np.transpose(idx)
# delete the feature by using the mask
s_list = s_list[idx]
length = len(s_list)/2
s_list = s_list.reshape((length, 2))
return np.array(F, dtype=int)
def score_cor(self, sel_idx):
X_sel = self.X[:, sel_idx]
n_samples, n_features = X_sel.shape
rff = 0
rcf = 0
for i in range(n_features):
fi = X_sel[:, i]
rcf += su_calculation(fi, self.y)
for j in range(n_features):
if j > i:
fj = X_sel[:, j]
rff += su_calculation(fi, fj)
rff *= 2
merits = rcf / np.sqrt(n_features + rff)
return -merits
def score_cor_fast(self, sel_idx):
rff = 0
rcf = 0
for i in sel_idx:
fi = self.X[:, i]
if self.rel_matrix[i] == -1:
self.rel_matrix[i] = su_calculation(fi, self.y)
rcf += self.rel_matrix[i]
for j in sel_idx:
if self.red_matrix[i][j] == -1:
fj = self.X[:, j]
self.red_matrix[i][j] = su_calculation(fi, fj)
self.red_matrix[j][i] = self.red_matrix[i][j]
if j > i:
rff += self.red_matrix[i][j]
rff *= 2
merits = rcf / np.sqrt(len(sel_idx) + rff)
return -merits