def test_digits_cosine_greedi_ll():
model = FacilityLocationSelection(100,
'cosine',
optimizer='greedi',
optimizer_kwds={
'optimizer1': 'lazy',
'optimizer2': 'lazy'
},
random_state=0)
model.fit(X_digits)
assert_array_equal(model.ranking[:30], digits_cosine_greedi_ranking[:30])
assert_array_almost_equal(model.gains[:30],
digits_cosine_greedi_gains[:30], 4)
def test_digits_cosine_stochastic_sparse(): model = FacilityLocationSelection(100, 'precomputed', optimizer='stochastic', random_state=0) model.fit(X_digits_cosine_sparse) assert_array_equal(model.ranking, digits_cosine_stochastic_ranking) assert_array_almost_equal(model.gains, digits_cosine_stochastic_gains, 4)
def create_apricot_dense(budget):
return FacilityLocationSelection(n_samples=budget,
metric='euclidean',
optimizer='lazy')
def test_digits_cosine_large_precomputed_greedy():
model = FacilityLocationSelection(100, 'precomputed', 100)
model.fit(X_digits_cosine_cupy)
assert_array_equal(model.ranking, digits_cosine_ranking)
assert_array_almost_equal(model.gains, digits_cosine_gains, 4)
def test_digits_cosine_large_precomputed_truncated_pivot():
model = FacilityLocationSelection(150, 'precomputed', 50)
model.fit(X_digits_sparse)
assert_array_equal(model.ranking[:100], digits_cosine_ranking)
assert_array_almost_equal(model.gains[:100], digits_cosine_gains, 4)
def test_digits_cosine_large_truncated():
model = FacilityLocationSelection(150, 'cosine', 1)
model.fit(X_digits)
assert_array_equal(model.ranking[:100], digits_cosine_ranking)
assert_array_almost_equal(model.gains[:100], digits_cosine_gains, 4)
def test_digits_cosine_small_truncated_pivot():
model = FacilityLocationSelection(15, 'cosine', 5)
model.fit(X_digits)
assert_array_equal(model.ranking[:10], digits_cosine_ranking[:10])
assert_array_almost_equal(model.gains[:10], digits_cosine_gains[:10], 4)
def test_digits_euclidean_large_truncated_pivot():
model = FacilityLocationSelection(150, 'euclidean', 10)
model.fit(X_digits)
assert_array_equal(model.ranking[:100], digits_euclidean_ranking)
assert_array_almost_equal(model.gains[:100], digits_euclidean_gains, 4)
def test_digits_precomputed_lazy():
model = FacilityLocationSelection(100, 'precomputed', optimizer='lazy')
model.fit(X_digits_corr_cupy)
assert_array_equal(model.ranking, digits_corr_ranking)
assert_array_almost_equal(model.gains, digits_corr_gains, 4)
def test_digits_corr_naive():
model = FacilityLocationSelection(100, 'corr', optimizer='naive')
model.fit(X_digits)
assert_array_equal(model.ranking, digits_corr_ranking)
assert_array_almost_equal(model.gains, digits_corr_gains, 4)
def test_digits_cosine_two_stage():
model = FacilityLocationSelection(100, 'cosine', optimizer='two-stage')
model.fit(X_digits)
assert_array_equal(model.ranking, digits_cosine_ranking)
assert_array_almost_equal(model.gains, digits_cosine_gains, 4)
def test_digits_euclidean_naive():
model = FacilityLocationSelection(100, 'euclidean', optimizer='naive')
model.fit(X_digits)
assert_array_equal(model.ranking[:30], digits_euclidean_ranking[:30])
assert_array_equal(model.ranking[-30:], digits_euclidean_ranking[-30:])
assert_array_almost_equal(model.gains, digits_euclidean_gains, 4)
from apricot import FacilityLocationSelection
import numpy
import time
numpy.random.seed(8)
for n in [500]:
X = numpy.concatenate([numpy.random.normal(7.5, 1, size=(n, 2)),
numpy.random.normal(2, 1, size=(n, 2)),
numpy.random.normal(15, 1, size=(n, 2))])
start_time = time.time()
fl = FacilityLocationSelection(n, 'euclidean', n_greedy_samples=1)
fl.fit(X)
end_time = time.time()
print("n = ", str(n)," time: " + str(end_time - start_time))
print(fl.ranking)
def f_analysis(): num_subsets = 10 obj = FacilityLocationSelection(num_subsets, metric='euclidean', optimizer='lazy') obj=obj.fit(data) subsets= obj.transform(data)
def test_digits_euclidean_small_truncated():
model = FacilityLocationSelection(15, 'euclidean', 1)
model.fit(X_digits)
assert_array_equal(model.ranking[:10], digits_euclidean_ranking[:10])
assert_array_almost_equal(model.gains[:10], digits_euclidean_gains[:10], 4)
def test_digits_cosine_lazy_object():
model = FacilityLocationSelection(100, 'cosine', optimizer=LazyGreedy())
model.fit(X_digits)
assert_array_equal(model.ranking, digits_cosine_ranking)
assert_array_almost_equal(model.gains, digits_cosine_gains, 4)
def test_digits_euclidean_large_pq():
model = FacilityLocationSelection(100, 'euclidean', 1)
model.fit(X_digits)
assert_array_equal(model.ranking, digits_euclidean_ranking)
assert_array_almost_equal(model.gains, digits_euclidean_gains, 4)
def test_digits_cosine_stochastic_object():
model = FacilityLocationSelection(
100, 'cosine', optimizer=StochasticGreedy(random_state=0))
model.fit(X_digits)
assert_array_equal(model.ranking, digits_cosine_stochastic_ranking)
assert_array_almost_equal(model.gains, digits_cosine_stochastic_gains, 4)
def test_digits_cosine_small_pq():
model = FacilityLocationSelection(10, 'cosine', 1)
model.fit(X_digits)
assert_array_equal(model.ranking, digits_cosine_ranking[:10])
assert_array_almost_equal(model.gains, digits_cosine_gains[:10], 4)
def test_digits_cosine_lazy_sparse():
model = FacilityLocationSelection(100, 'precomputed', optimizer='lazy')
model.fit(X_digits_cosine_sparse)
assert_array_equal(model.ranking, digits_cosine_ranking)
assert_array_almost_equal(model.gains, digits_cosine_gains, 4)
def test_digits_cosine_large_pivot():
model = FacilityLocationSelection(100, 'cosine', 50)
model.fit(X_digits)
assert_array_equal(model.ranking, digits_cosine_ranking)
assert_array_almost_equal(model.gains, digits_cosine_gains, 4)
import seaborn
seaborn.set_style('whitegrid')
from apricot import FacilityLocationSelection
numpy.random.seed(0)
X = numpy.concatenate([
numpy.random.normal((1, 1), 0.5, size=(15, 2)),
numpy.random.normal((6, 3), 0.5, size=(25, 2)),
numpy.random.normal((5, 7), 0.5, size=(40, 2)),
numpy.random.normal((1, 7), 0.5, size=(30, 2)),
numpy.random.normal((10, 4), 0.5, size=(15, 2)),
numpy.random.normal((3, 4), 0.5, size=(15, 2))
])
Xi = FacilityLocationSelection(6, 'euclidean').fit_transform(X)
Xr = numpy.random.choice(numpy.arange(X.shape[0]), size=6)
Xr = X[Xr]
fig = plt.figure(figsize=(8, 6))
ax = plt.subplot(111)
ax.scatter(X[:, 0], X[:, 1], s=10)
ax.legend(fontsize=14)
ax.set_xlim(-1, 14)
#ax.set_ylim(0, 7)
ax.axis('off')
plt.grid(False)
seaborn.despine(ax=ax)
fig.set_tight_layout(True)
def test_digits_cosine_small_precomputed_truncated():
model = FacilityLocationSelection(15, 'precomputed', 1)
model.fit(X_digits_sparse)
assert_array_equal(model.ranking[:10], digits_cosine_ranking[:10])
assert_array_almost_equal(model.gains[:10], digits_cosine_gains[:10], 4)
def test_digits_corr_large_greedy():
model = FacilityLocationSelection(100, 'corr', 100)
model.fit(X_digits)
assert_array_equal(model.ranking, digits_corr_ranking)
assert_array_almost_equal(model.gains, digits_corr_gains, 4)
def test_digits_corr_small_precomputed_greedy():
model = FacilityLocationSelection(10, 'precomputed', 10)
model.fit(X_digits_corr_cupy)
assert_array_equal(model.ranking, digits_corr_ranking[:10])
assert_array_almost_equal(model.gains, digits_corr_gains[:10], 4)
def test_digits_corr_large_truncated_pivot():
model = FacilityLocationSelection(150, 'corr', 50)
model.fit(X_digits)
assert_array_equal(model.ranking[:100], digits_corr_ranking)
assert_array_almost_equal(model.gains[:100], digits_corr_gains, 4)
def create_apricot_sparse(budget, num_neighbors):
return FacilityLocationSelection(n_samples=budget,
metric='euclidean',
optimizer='lazy',
n_neighbors=num_neighbors)
def test_digits_euclidean_small_pivot():
model = FacilityLocationSelection(10, 'euclidean', 5)
model.fit(X_digits)
assert_array_equal(model.ranking, digits_euclidean_ranking[:10])
assert_array_almost_equal(model.gains, digits_euclidean_gains[:10], 4)
def apricot_dense():
obj = FacilityLocationSelection(n_samples=budget, metric='euclidean', optimizer='lazy')
obj.fit_transform(dataArray)
def test_digits_cosine_two_stage_object(): model = FacilityLocationSelection(100, 'cosine', optimizer=TwoStageGreedy()) model.fit(X_digits) assert_array_equal(model.ranking, digits_cosine_ranking) assert_array_almost_equal(model.gains, digits_cosine_gains, 4) assert_array_almost_equal(model.subset, X_digits[model.ranking])