def test_iris(self):
itml = ITML_Supervised(num_constraints=200)
itml.fit(self.iris_points, self.iris_labels)
csep = class_separation(itml.transform(self.iris_points),
self.iris_labels)
self.assertLess(csep, 0.2)
def itml_cmc(features, train_idxs, query_idxs, camId, gallery_idxs, labels):
N, m = features[train_idxs].shape
# features[train_idxs][:1000, ].shape
eigvals, eigvecs = calc_eig_pca_small(features[train_idxs].T, m, N)
m = 50
m_eigvecs = eigvecs[:, :m]
avg_face = compute_avg_face(features[train_idxs].T)
phi = features - avg_face
m_features = np.dot(phi, m_eigvecs)
itml = ITML_Supervised(verbose=True, num_constraints=5000, gamma=0.2)
X = m_features[train_idxs]
Y = labels[train_idxs]
X_itml = itml.fit_transform(X, Y)
M = itml.metric()
nn_idx_mat = evaluation(
knn,
features=m_features,
gallery_idxs=gallery_idxs,
query_idxs=query_idxs,
camId=camId,
labels=labels,
metric='mahalanobis',
metric_params={'VI': M}
)
return plot_CMC(nn_idx_mat, query_idxs, labels)
def main():
# Get training file name from the command line
traindatafile = sys.argv[1]
# The training file is in libSVM format
tr_data = load_svmlight_file(traindatafile)
Xtr = tr_data[0].toarray()
# Converts sparse matrices to dense
Ytr = tr_data[1]
# The trainig labels
Indices_array = np.arange(Ytr.shape[0])
np.random.shuffle(Indices_array)
Xtr = Xtr[Indices_array]
Xtr = Xtr[:6000]
Ytr = Ytr[Indices_array]
Ytr = Ytr[:6000]
itml = ITML_Supervised()
itml.fit(Xtr, Ytr)
Met = itml.metric()
# print Met;
np.save("itml_model.npy", Met)
def test_iris(self):
num_constraints = 200
itml = ITML_Supervised(num_constraints=num_constraints).fit(self.iris_points, self.iris_labels)
csep = class_separation(itml.transform(), self.iris_labels)
self.assertLess(csep, 0.4) # it's not great
def process_itml(self, **option):
'''Metric Learning algorithm: ITML'''
GeneExp = self.GeneExp_train
Label = self.Label_train
itml = ITML_Supervised(**option)
itml.fit(GeneExp, Label)
self.Trans['ITML'] = itml.transformer()
def test_iris(self):
num_constraints = 200
itml = ITML_Supervised(num_constraints=num_constraints).fit(
self.iris_points, self.iris_labels)
csep = class_separation(itml.transform(), self.iris_labels)
self.assertLess(csep, 0.4) # it's not great
def get_metric():
ad=pd.read_csv('ad_feature.csv',header=0,sep='\t')
data=ad.values
m=np.array([[.0,.0,.0],[.0,.0,.0],[.0,.0,.0]])
itml = ITML_Supervised(num_constraints=200)
for i in range(6):
data_r=np.array(random.sample(data.tolist(),int(len(data)/300)))
x=data_r[:,[2,3,4]]
y=data_r[:,1]
itml.fit(x,y)
m=m+itml.metric()
m=m/6
return m
def test_bounds_parameters_valid(bounds): """Asserts that we can provide any array-like of two elements as bounds, and that the attribute bound_ is a numpy array""" pairs = np.array([[[-10., 0.], [10., 0.]], [[0., 50.], [0., -60]]]) y_pairs = [1, -1] itml = ITML() itml.fit(pairs, y_pairs, bounds=bounds) X = np.array([[0, 0], [0, 1], [2, 0], [2, 1]]) y = np.array([1, 0, 1, 0]) itml_supervised = ITML_Supervised() itml_supervised.fit(X, y, bounds=bounds)
def test_bounds_parameters_valid(bounds):
"""Asserts that we can provide any array-like of two elements as bounds,
and that the attribute bound_ is a numpy array"""
pairs = np.array([[[-10., 0.], [10., 0.]], [[0., 50.], [0., -60]]])
y_pairs = [1, -1]
itml = ITML()
itml.fit(pairs, y_pairs, bounds=bounds)
X = np.array([[0, 0], [0, 1], [2, 0], [2, 1]])
y = np.array([1, 0, 1, 0])
itml_supervised = ITML_Supervised()
itml_supervised.fit(X, y, bounds=bounds)
def test_bounds_parameters_invalid(bounds):
"""Assert that if a non array-like is put for bounds, or an array-like
of length different than 2, an error is returned"""
pairs = np.array([[[-10., 0.], [10., 0.]], [[0., 50.], [0., -60]]])
y_pairs = [1, -1]
itml = ITML()
with pytest.raises(Exception):
itml.fit(pairs, y_pairs, bounds=bounds)
X = np.array([[0, 0], [0, 1], [2, 0], [2, 1]])
y = np.array([1, 0, 1, 0])
itml_supervised = ITML_Supervised()
with pytest.raises(Exception):
itml_supervised.fit(X, y, bounds=bounds)
def test_bounds_parameters_invalid(bounds):
"""Assert that if a non array-like is put for bounds, or an array-like
of length different than 2, an error is returned"""
pairs = np.array([[[-10., 0.], [10., 0.]], [[0., 50.], [0., -60]]])
y_pairs = [1, -1]
itml = ITML()
with pytest.raises(Exception):
itml.fit(pairs, y_pairs, bounds=bounds)
X = np.array([[0, 0], [0, 1], [2, 0], [2, 1]])
y = np.array([1, 0, 1, 0])
itml_supervised = ITML_Supervised()
with pytest.raises(Exception):
itml_supervised.fit(X, y, bounds=bounds)
def sandwich_demo():
x, y = sandwich_data()
knn = nearest_neighbors(x, k=2)
ax = plt.subplot(3, 1, 1) # take the whole top row
plot_sandwich_data(x, y, ax)
plot_neighborhood_graph(x, knn, y, ax)
ax.set_title('input space')
ax.set_aspect('equal')
ax.set_xticks([])
ax.set_yticks([])
mls = [
LMNN(),
ITML_Supervised(num_constraints=200),
SDML_Supervised(num_constraints=200),
LSML_Supervised(num_constraints=200),
]
for ax_num, ml in enumerate(mls, start=3):
ml.fit(x, y)
tx = ml.transform()
ml_knn = nearest_neighbors(tx, k=2)
ax = plt.subplot(3, 2, ax_num)
plot_sandwich_data(tx, y, axis=ax)
plot_neighborhood_graph(tx, ml_knn, y, axis=ax)
ax.set_title(ml.__class__.__name__)
ax.set_xticks([])
ax.set_yticks([])
plt.show()
class ITML:
def __init__(self, num_constraints=200):
self.space_model = PCA()
self.metric_model = ITML_Supervised(num_constraints)
def fit(self, feats, labels):
"""Fits the model to the prescribed data."""
pdb.set_trace()
self.eigenvecs, self.space = self.space_model.fit(feats, labels)
pdb.set_trace()
self.metric_model.fit(self.space.T, labels)
def transform(self, y):
"""Transforms the test data according to the model"""
test_proj, _ = self.space_model.transform(y)
pdb.set_trace()
return self.metric_model.transform(y)
def test_itml_supervised(self):
seed = np.random.RandomState(1234)
itml = ITML_Supervised(n_constraints=200, random_state=seed)
itml.fit(self.X, self.y)
res_1 = itml.transform(self.X)
seed = np.random.RandomState(1234)
itml = ITML_Supervised(n_constraints=200, random_state=seed)
res_2 = itml.fit_transform(self.X, self.y)
assert_array_almost_equal(res_1, res_2)
def test_deprecation(self):
# test that the right deprecation message is thrown.
# TODO: remove in v.0.5
X = np.array([[0, 0], [0, 1], [2, 0], [2, 1]])
y = np.array([1, 0, 1, 0])
itml_supervised = ITML_Supervised(num_labeled=np.inf)
msg = ('"num_labeled" parameter is not used.'
' It has been deprecated in version 0.5.0 and will be'
'removed in 0.6.0')
assert_warns_message(DeprecationWarning, msg, itml_supervised.fit, X,
y)
def test_deprecation_bounds(self):
# test that a deprecation message is thrown if bounds is set at
# initialization
# TODO: remove in v.0.6
X = np.array([[0, 0], [0, 1], [2, 0], [2, 1]])
y = np.array([1, 0, 1, 0])
itml_supervised = ITML_Supervised(bounds=None)
msg = ('"bounds" parameter from initialization is not used.'
' It has been deprecated in version 0.5.0 and will be'
'removed in 0.6.0. Use the "bounds" parameter of this '
'fit method instead.')
assert_warns_message(DeprecationWarning, msg, itml_supervised.fit, X,
y)
def runITML(X_train, X_test, y_train, y_test):
transformer = ITML_Supervised(num_constraints=200, verbose=True)
transformer.fit(X_train, y_train)
X_train_proj = transformer.transform(X_train)
X_test_proj = transformer.transform(X_test)
np.save('X_train_ITML', X_train_proj)
np.save('X_test_ITML', X_test_proj)
return X_train_proj, X_test_proj
class ITML:
def __init__(self, num_constraints=200):
self.metric_model = ITML_Supervised(num_constraints)
def fit(self, features, labels):
"""Fits the model to the prescribed data."""
return self.metric_model.fit(features, labels)
def transform(self, y):
"""Transforms the test data according to the model"""
return self.metric_model.transform(y)
def predict_proba(self, X_te):
"""Predicts the probabilities of each of the test samples"""
test_samples = X_te.shape[0]
self.X_tr = self.transform(self.X_tr)
clf = NearestCentroid()
clf.fit(self.X_tr, self.y_train)
centroids = clf.centroids_
probabilities = np.zeros((test_samples, centroids.shape[0]))
for sample in xrange(test_samples):
probabilities[sample] = sk_nearest_neighbour_proba(
centroids, X_te[sample, :])
return probabilities
def test_itml_supervised(self):
seed = np.random.RandomState(1234)
itml = ITML_Supervised(num_constraints=200)
itml.fit(self.X, self.y, random_state=seed)
res_1 = itml.transform(self.X)
seed = np.random.RandomState(1234)
itml = ITML_Supervised(num_constraints=200)
res_2 = itml.fit_transform(self.X, self.y, random_state=seed)
assert_array_almost_equal(res_1, res_2)
def get_dist_func(
data: Array[np.float64], target: Array[np.float64]
) -> Callable[[Callable[[np.float64, np.float64], np.float64], np.int, np.int],
np.float64]:
"""
Get function that returns distances between examples in learned space.
Args:
data : Array[np.float64] - training data_trans
target : int - target variable values (classes of training examples)
Returns:
Callable[[Callable[[np.float64, np.float64], np.float64], np.int, np.int], np.float64] -- higher
order function that takes a matric function and returns a function that takes two indices of examples
and returns distance between examples in learned metric space.
"""
# Get transformed data.
data_trans: Array[np.float64] = ITML_Supervised().fit_transform(
StandardScaler().fit_transform(data), target)
# Computing distance:
def dist_func_res(metric: Callable[[np.float64, np.float64], np.float64],
i1: np.int, i2: np.int) -> np.float64:
"""
distance function that takes indices of examples in training set and returns distance
in learned space using specified distance metric.
Args:
i1 : int - index of first training example
i2 : int - index of second training example
Returns:
np.float64 - distance in learned metric space using specified metric
between specified training examples.
"""
# Compute distance in learned metric space using specified metric.
return metric(data_trans[i1, :], data_trans[i2, :])
return dist_func_res # Return distance function.
map(lambda x: x.__class__.__name__,
[learner for (learner, _) in quadruplets_learners]))
pairs_learners = [
(ITML(), build_pairs),
(MMC(max_iter=2), build_pairs), # max_iter=2 for faster
(SDML(), build_pairs),
]
ids_pairs_learners = list(
map(lambda x: x.__class__.__name__,
[learner for (learner, _) in pairs_learners]))
classifiers = [(Covariance(), build_classification),
(LFDA(), build_classification), (LMNN(), build_classification),
(NCA(), build_classification), (RCA(), build_classification),
(ITML_Supervised(max_iter=5), build_classification),
(LSML_Supervised(), build_classification),
(MMC_Supervised(max_iter=5), build_classification),
(RCA_Supervised(num_chunks=10), build_classification),
(SDML_Supervised(), build_classification)]
ids_classifiers = list(
map(lambda x: x.__class__.__name__,
[learner for (learner, _) in classifiers]))
regressors = [(MLKR(), build_regression)]
ids_regressors = list(
map(lambda x: x.__class__.__name__,
[learner for (learner, _) in regressors]))
WeaklySupervisedClasses = (_PairsClassifierMixin, _QuadrupletsClassifierMixin)
def main():
print("importing data...")
data = loadmat('assets/cuhk03_new_protocol_config_labeled.mat')
with open('assets/feature_data.json') as f:
features = ujson.load(f)
print("data imported")
features = np.array(features)
train_idxs = data['train_idx'].flatten() - 1
query_idxs = data['query_idx'].flatten() - 1
camId = data['camId'].flatten()
gallery_idxs = data['gallery_idx'].flatten() - 1
labels = data['labels'].flatten()
N, m = features[train_idxs].shape
# features[train_idxs][:1000, ].shape
eigvals, eigvecs = calc_eig_pca_small(features[train_idxs].T, m, N)
m = 50
m_eigvecs = eigvecs[:, :m]
avg_face = compute_avg_face(features[train_idxs].T)
phi = features - avg_face
m_features = np.dot(phi, m_eigvecs)
itml = ITML_Supervised(verbose=True, num_constraints=5000, gamma=0.1)
X = m_features[train_idxs]
Y = labels[train_idxs]
X_itml = itml.fit_transform(X, Y)
M = itml.metric()
plot_3d(X_itml, Y)
nn_idx_mat = evaluation(knn,
features=m_features,
gallery_idxs=gallery_idxs,
query_idxs=query_idxs,
camId=camId,
labels=labels,
metric='mahalanobis',
metric_params={'VI': M})
acc = get_all_rank_acc(nn_idx_mat, query_idxs, labels)
print("Accuracy:")
print(acc)
test_set_idxs = np.append(gallery_idxs, query_idxs)
features_ITML = itml.transform(m_features)
X_test = features_ITML[test_set_idxs]
Y_test = labels[test_set_idxs]
n_cluster = np.unique(Y_test).size
nmi_kmean, acc_kmean = evaluation_k_means(X_test, n_cluster, Y_test)
print("ITML k-means accuracy (test set):")
print(acc_kmean)
gamma = [i / 10 for i in range(1, 11)]
X_itmls = []
all_rank_acc_g = []
for g in gamma:
itml = ITML_Supervised(verbose=True, num_constraints=5000, gamma=0.2)
X = m_features[train_idxs]
X_itml = itml.fit_transform(X, Y)
X_itmls.append(X_itml)
M = itml.metric()
nn_idx_mat = evaluation(knn,
features=m_features,
gallery_idxs=gallery_idxs,
query_idxs=query_idxs,
camId=camId,
labels=labels,
metric='mahalanobis',
metric_params={'VI': M})
acc_g = get_all_rank_acc(nn_idx_mat, query_idxs, labels)
all_rank_acc_g.append(acc_g)
plt.plot(gamma, all_rank_acc_g)
plt.legend(('Rank 1', 'Rank 5', 'Rank10'))
plt.ylabel('Accuracy')
plt.xlabel('gamma')
print(all_rank_acc_g)
plt.show()
def test_ITML():
X = np.random.rand(40, 40)
Y = np.array([i for j in range(2) for i in range(20)])
itml = ITML_Supervised(num_constraints=200)
itml.fit(X, Y)
pdb.set_trace()
def test_itml(self):
check_estimator(ITML_Supervised())
from models.parts import PartsNet
from models.triplet import TripletNet
from models.voting import VotingNet
from plotter import Plot
from trainer import Trainer
name = 'triplet-sgd-nopool' + datetime.now().strftime('_%Y-%m-%d_%H%M%S')
plot = Plot(name)
net = TripletNet(ConvNet())
net.load_state_dict(torch.load('triplet-sgd_2018-05-10_101323_best'))
# net = VotingNet(BkwNet())
net.cuda()
train, val, test = VIPeR.create((316, 380), shuffle_seed=12345)
metric = ITML_Supervised()
metric_learn(metric, net, train)
criterion = nn.TripletMarginLoss().cuda()
optimizer = optim.SGD(net.parameters(), lr=1e-2, momentum=0.9)
scheduler = scheduler.ReduceLROnPlateau(optimizer,
patience=1,
eps=1e-8,
verbose=True)
trainer = Trainer(name,
net, (train, val, test),
optimizer,
scheduler,
criterion,
plot,
def main(params):
initialize_results_dir(params.get('results_dir'))
backup_params(params, params.get('results_dir'))
print('>>> loading data...')
X_train, y_train, X_test, y_test = LoaderFactory().create(
name=params.get('dataset'),
root=params.get('dataset_dir'),
random=True,
seed=params.getint('split_seed'))()
print('<<< data loaded')
print('>>> computing psd matrix...')
if params.get('algorithm') == 'identity':
psd_matrix = np.identity(X_train.shape[1], dtype=X_train.dtype)
elif params.get('algorithm') == 'nca':
nca = NCA(init='auto',
verbose=True,
random_state=params.getint('algorithm_seed'))
nca.fit(X_train, y_train)
psd_matrix = nca.get_mahalanobis_matrix()
elif params.get('algorithm') == 'lmnn':
lmnn = LMNN(init='auto',
verbose=True,
random_state=params.getint('algorithm_seed'))
lmnn.fit(X_train, y_train)
psd_matrix = lmnn.get_mahalanobis_matrix()
elif params.get('algorithm') == 'itml':
itml = ITML_Supervised(verbose=True,
random_state=params.getint('algorithm_seed'))
itml.fit(X_train, y_train)
psd_matrix = itml.get_mahalanobis_matrix()
elif params.get('algorithm') == 'lfda':
lfda = LFDA()
lfda.fit(X_train, y_train)
psd_matrix = lfda.get_mahalanobis_matrix()
elif params.get('algorithm') == 'arml':
learner = TripleLearner(
optimizer=params.get('optimizer'),
optimizer_params={
'lr': params.getfloat('lr'),
'momentum': params.getfloat('momentum'),
'weight_decay': params.getfloat('weight_decay'),
},
criterion=params.get('criterion'),
criterion_params={'calibration': params.getfloat('calibration')},
n_epochs=params.getint('n_epochs'),
batch_size=params.getint('batch_size'),
random_initialization=params.getboolean('random_initialization',
fallback=False),
update_triple=params.getboolean('update_triple', fallback=False),
device=params.get('device'),
seed=params.getint('learner_seed'))
psd_matrix = learner(X_train,
y_train,
n_candidate_mins=params.getint('n_candidate_mins',
fallback=1))
else:
raise Exception('unsupported algorithm')
print('<<< psd matrix got')
np.savetxt(os.path.join(params.get('results_dir'), 'psd_matrix.txt'),
psd_matrix)
class MLPipe:
pipe = Pipeline([('scaling', StandardScaler()),
('feature_selection',
SelectFromModel(RandomForestClassifier(n_estimators=100, random_state=42), threshold='median')),
('metric_learning', None),
('classifier', SVC())])
save_path = './titanic/pipe_{}.bin'
feature_selection_param_grid = {
'SVC': [
{
'scaling': [StandardScaler(), None],
'metric_learning': [None, LMNN()],
'feature_selection': [SelectFromModel(RandomForestClassifier(n_estimators=100, random_state=42), threshold='median'), None],
# 'feature_selection__estimator': [RandomForestClassifier(n_estimators=100, random_state=42), SVC(C=1000), KNeighborsClassifier()],
'classifier': [SVC()],
'classifier__kernel': ['rbf'],
'classifier__C': [0.001, 0.01, 0.1, 1, 10, 100],
'classifier__gamma': [0.001, 0.01, 0.1, 1, 10, 100]
},
{
'scaling': [StandardScaler(), None],
'metric_learning': [None, LMNN()],
'feature_selection': [SelectFromModel(RandomForestClassifier(n_estimators=100, random_state=42), threshold='median'), None],
'classifier': [SVC()],
'classifier__kernel': ['linear'],
'classifier__C': [0.001, 0.01, 0.1, 1, 10, 100],
}
],
'rfc': [
{
#'scaling': [StandardScaler(), None],
'scaling': [None],
'metric_learning': [None, LMNN()],
'feature_selection': [SelectFromModel(RandomForestClassifier(n_estimators=100, random_state=42), threshold='median'), None],
'classifier': [RandomForestClassifier()],
'classifier__n_estimators': [10, 25, 50, 75, 100],
'classifier__max_depth': [None, 5, 10, 25],
'classifier__min_samples_split': [5, 10, 15]
}
],
'knn': [
{
'scaling': [StandardScaler(), MinMaxScaler(), None],
'metric_learning': [None, LMNN(), ITML_Supervised(num_constraints=200)],
'feature_selection': [
SelectFromModel(RandomForestClassifier(n_estimators=100, random_state=42), threshold='median'),
None],
'classifier': [KNeighborsClassifier()],
'classifier__n_neighbors': [2, 3, 4, 5],
'classifier__algorithm': ['auto', 'ball_tree', 'kd_tree']
}
],
'dt': [
{
'scaling': [StandardScaler(), MinMaxScaler(), None],
'metric_learning': [None],
'feature_selection': [
SelectFromModel(RandomForestClassifier(n_estimators=100, random_state=42), threshold='median'),
None],
'classifier': [DecisionTreeClassifier()],
'classifier__criterion': ['gini', 'entropy'],
'classifier__max_features': ['auto', 'sqrt', 'log2'],
'classifier__max_depth': [None, 5, 10, 15]
}
],
'gbc': [
{
'scaling': [StandardScaler(), None],
'metric_learning': [None, LMNN()],
'feature_selection': [
SelectFromModel(RandomForestClassifier(n_estimators=100, random_state=42), threshold='median'),
None],
'classifier': [GradientBoostingClassifier()],
'classifier__loss': ['deviance'],
'classifier__learning_rate': [0.1, 1, 10],
'classifier__n_estimators': [10, 50, 100],
'classifier__criterion': ['friedman_mse'],
'classifier__max_features': ['auto'],
'classifier__max_depth': [None, 2, 5, 10, 15, 25],
'classifier__min_samples_split': [5, 10, 15]
}
],
'xgb': [
{
'scaling': [StandardScaler()],#, None],
'metric_learning': [None],#, LMNN(), ITML_Supervised(num_constraints=200)],
'feature_selection': [None],
'classifier': [xgb.XGBClassifier()],
'classifier__n_estimators': [500, 1000, 2000],
'classifier__max_depth': [4, 6, 8, 10],
'classifier__min_child_weight': [1, 2, 3],
'classifier__gamma': [0.4, 0.6, 0.8, 0.9, 1],
'classifier__subsample': [0.4, 0.6, 0.8, 1.0],
'classifier__colsample_bytree': [0.4, 0.6, 0.8, 1.0]
}
]
}
def __init__(self, model_name: str):
print('model_name: %s' % model_name)
self._model_name = model_name
self._param_grid = MLPipe.feature_selection_param_grid[model_name]
self._save_path = MLPipe.save_path.format(model_name)
self._save_best_path = self._save_path + '-best'
self._model = None
self._pipe = MLPipe.pipe
def fit_model(self, train_X: list, train_y: list):
model = load_model(self._save_path)
if not model:
# create model, if not loading file
grid_search = GridSearchCV(self._pipe, self._param_grid, cv=5, n_jobs=-1)
grid_search.fit(train_X, train_y)
save_model(self._save_path, grid_search)
model = grid_search
print('best score: {:.2f}'.format(model.best_score_))
print('best estimator \n{}'.format(model.best_estimator_))
self._model = model.best_estimator_
def predict(self, test_X: list) -> list:
test_y = self._model.predict(test_X).astype(int)
return test_y
def get_model(self) -> dict:
return self._model
def save_best_model(self):
save_model(self._save_best_path, self._model)
def load_best_model(self):
self._model = load_model(self._save_best_path)
def get_cv_failure_data(self, train_X: list, train_y: list):
ret_index = np.array([])
evaluate_model = self._model
kf = KFold(n_splits=5)
for train_index, test_index in kf.split(train_X):
evaluate_model.fit(train_X[train_index], train_y[train_index])
evaluate_y = evaluate_model.predict(train_X[test_index])
correct_eval_y = train_y[test_index]
ret_index = np.concatenate((ret_index, np.array(test_index)[evaluate_y != train_y[test_index]]))
return list(ret_index.astype(int))
def test_itml_supervised(self): seed = np.random.RandomState(1234) itml = ITML_Supervised(num_constraints=200) itml.fit(self.X, self.y, random_state=seed) L = itml.transformer_ assert_array_almost_equal(L.T.dot(L), itml.metric())
def test_itml_supervised(self): seed = np.random.RandomState(1234) itml = ITML_Supervised(num_constraints=200, random_state=seed) itml.fit(self.X, self.y) L = itml.components_ assert_array_almost_equal(L.T.dot(L), itml.get_mahalanobis_matrix())
dist_func=lambda x1, x2: np.sqrt(np.sum(np.abs(x1 - x2)**2.0, 1)))
}
# Initialize dictionary for storing results.
res_dict = dict.fromkeys(rbas.keys())
for key in res_dict.keys():
res_dict[key] = np.empty(NUM_FEATURES_TO_SELECT_LIM, dtype=np.float)
# Go over RBAs.
for rba_name in rbas.keys():
print("### Testing {0} ###".format(rba_name))
# Initialize next pipeline.
clf_pipeline = Pipeline([('scaling', StandardScaler()),
('lmf', ITML_Supervised()),
('rba', rbas[rba_name]), ('clf', clf)])
# Go over values on x axis.
for num_features_to_select in np.arange(1, NUM_FEATURES_TO_SELECT_LIM + 1):
print("{0}/{1}".format(num_features_to_select,
NUM_FEATURES_TO_SELECT_LIM))
# Set parameter.
clf_pipeline.set_params(
rba__n_features_to_select=num_features_to_select)
# Compute score of 10 runs of 10 fold cross-validation.
score = np.mean(
cross_val_score(clf_pipeline,
from metric_learn import ITML_Supervised from sklearn.datasets import load_iris iris_data = load_iris() X = iris_data['data'] Y = iris_data['target'] itml = ITML_Supervised(num_constraints=200) itml.fit(X, Y)
t0 = time()
pca = RandomizedPCA(n_components=n_components, whiten=True).fit(X_train)
print("done in %0.3fs" % (time() - t0))
eigenfaces = pca.components_.reshape((n_components, h, w))
print("Projecting the input data on the eigenfaces orthonormal basis")
t0 = time()
X_train_pca = pca.transform(X_train)
X_test_pca = pca.transform(X_test)
print("done in %0.3fs" % (time() - t0))
# Try LMNN here.
print("Trying ITML")
param_grid = {''}
itml = ITML(num_constraints=200)
X_tr = itml.fit(X_train_pca, y_train).transform(X_train_pca)
X_te = itml.transform(X_test_pca)
acc, y_pred = classifier.sk_nearest_neighbour(X_tr, y_train, X_te, y_test)
print("accuracy = %s",acc)
print(classification_report(y_test, y_pred, target_names=target_names))
print(confusion_matrix(y_test, y_pred, labels=range(n_classes)))
###############################################################################
# Train a SVM classification model
print("Fitting the classifier to the training set")
t0 = time()
param_grid = {'C': [1e3, 5e3, 1e4, 5e4, 1e5],
def test_iris(self):
itml = ITML_Supervised(num_constraints=200)
itml.fit(self.iris_points, self.iris_labels)
csep = class_separation(itml.transform(self.iris_points), self.iris_labels)
self.assertLess(csep, 0.2)
# Compute PCA_NCA Learning
print("\n-----PCA_NCA-----")
nca = NCA(max_iter=20, verbose=True)
start_time = time.time()
nca.fit(pca.train_sample_projection, original_train_labels)
end_time = time.time()
print("Learning time: %s" % (end_time - start_time))
transformed_query_features = nca.transform(pca_query_features)
transformed_gallery_features = nca.transform(pca_gallery_features)
compute_k_mean(num_of_clusters, transformed_query_features,
transformed_gallery_features, gallery_labels)
# Compute ITML (Information Theoretic Metric Learning)
print("\n-----ITML-----")
itml = ITML_Supervised(max_iter=20,
convergence_threshold=1e-5,
num_constraints=500,
verbose=True)
itml.fit(original_train_features, original_train_labels)
transformed_query_features = itml.transform(query_features)
transformed_gallery_features = itml.transform(gallery_features)
compute_k_mean(num_of_clusters, transformed_query_features,
transformed_gallery_features, gallery_labels)
# Compute PCA_ITML
print("\n-----PCA_ITML-----")
itml = ITML_Supervised(max_iter=20,
convergence_threshold=1e-5,
num_constraints=500,
verbose=True)
start_time = time.time()
itml.fit(pca.train_sample_projection, original_train_labels)
def test_itml_supervised(self): seed = np.random.RandomState(1234) itml = ITML_Supervised(num_constraints=200) itml.fit(self.X, self.y, random_state=seed) L = itml.transformer_ assert_array_almost_equal(L.T.dot(L), itml.get_mahalanobis_matrix())
if Method == 'LMNN':
print("Method: LMNN", '\n')
lmnn = LMNN(k=3, learn_rate=1e-6, verbose=False)
x = lmnn.fit(FSTrainData, TrainLabels)
TFSTestData = x.transform(FSTestData)
print('Transformation Done', '\n')
elif Method == 'COV':
print("Method: COV", '\n')
cov = Covariance().fit(FSTrainData)
TFSTestData = cov.transform(FSTestData)
print('Transformation Done', '\n')
elif Method == 'ITML':
print("Method: ITML", '\n')
itml = ITML_Supervised(num_constraints=200, A0=None)
x = itml.fit(FSTrainData, TrainLabels)
TFSTestData = x.transform(FSTestData)
print('Transformation Done', '\n')
elif Method == 'LFDA':
print("Method: LFDA", '\n')
lfda = LFDA(k=4, dim=1)
x = lfda.fit(FSTrainData, TrainLabels)
TFSTestData = x.transform(FSTestData)
print('Transformation Done', '\n')
elif Method == 'NCA':
print("Method: NCA", '\n')
#print('Max', TrainData.max(axis=0))
#print('sssssssss', len(TrainData[0]))
