def plot_xor_xnor_xor(num_data_points):
"""Visualize Gaussian XOR and Gaussian XNOR Data"""
colors = sns.color_palette("Dark2", n_colors=2)
fig, ax = plt.subplots(1, 3, figsize=(24, 8))
xor_1, y_xor_1 = generate_gaussian_parity(num_data_points)
xor_2, y_xor_2 = generate_gaussian_parity(num_data_points)
r_xor, y_rxor = generate_gaussian_parity(num_data_points,
angle_params=np.pi / 2)
ax[0].scatter(xor_1[:, 0],
xor_1[:, 1],
c=get_colors(colors, y_xor_1),
s=50)
ax[1].scatter(r_xor[:, 0], r_xor[:, 1], c=get_colors(colors, y_rxor), s=50)
ax[2].scatter(xor_2[:, 0],
xor_2[:, 1],
c=get_colors(colors, y_xor_2),
s=50)
ax[0].set_title("Gaussian XOR", fontsize=30)
ax[1].set_title("Gaussian XNOR", fontsize=30)
ax[2].set_title("Gaussian XOR", fontsize=30)
ax[0].set_xticks([])
ax[1].set_xticks([])
ax[2].set_xticks([])
ax[0].set_yticks([])
ax[1].set_yticks([])
ax[2].set_yticks([])
plt.show()
c = [colors[i] for i in inds]
return c
#%%#%% Plotting the result
# mc_rep = 50
fontsize = 30
labelsize = 28
fig = plt.figure(constrained_layout=True, figsize=(25, 23))
gs = fig.add_gridspec(23, 25)
colors = sns.color_palette("Dark2", n_colors=2)
X, Y = generate_gaussian_parity(750)
Z, W = generate_gaussian_parity(750, angle_params=np.pi / 2)
P, Q = generate_gaussian_parity(750, angle_params=np.pi / 4)
ax = fig.add_subplot(gs[:6, 2:8])
ax.scatter(X[:, 0], X[:, 1], c=get_colors(colors, Y), s=50)
ax.set_xticks([])
ax.set_yticks([])
ax.set_title("Gaussian XOR", fontsize=30)
plt.tight_layout()
ax.axis("off")
# plt.savefig('./result/figs/gaussian-xor.pdf')
#####################
def experiment(angle, classifiers, n_xor, n_rxor, n_test):
"""Perform XOR RXOR(XNOR) XOR experiment"""
X_xor, y_xor = generate_gaussian_parity(n_xor)
X_rxor, y_rxor = generate_gaussian_parity(n_rxor, angle_params=angle)
X_xor_2, y_xor_2 = generate_gaussian_parity(n_xor)
test_x_xor, test_y_xor = generate_gaussian_parity(n_test)
test_x_rxor, test_y_rxor = generate_gaussian_parity(n_test,
angle_params=angle)
X_stream = np.concatenate((X_xor, X_rxor, X_xor_2), axis=0)
y_stream = np.concatenate((y_xor, y_rxor, y_xor_2), axis=0)
# Instantiate classifiers
if classifiers[0] == 1:
ht = tree.HoeffdingTreeClassifier(grace_period=2,
split_confidence=1e-01)
if classifiers[1] == 1:
mf = MondrianForestClassifier(n_estimators=10)
if classifiers[2] == 1:
sdt = DecisionTreeClassifier()
if classifiers[3] == 1:
sdf = StreamDecisionForest()
if classifiers[4] == 1:
synf = LifelongClassificationForest(default_n_estimators=10)
errors = np.zeros((10, int(X_stream.shape[0] / 25)))
for i in range(int(X_stream.shape[0] / 25)):
X = X_stream[i * 25:(i + 1) * 25]
y = y_stream[i * 25:(i + 1) * 25]
# Hoeffding Tree Classifier
if classifiers[0] == 1:
ht_partial_fit(ht, X, y)
ht_xor_y_hat, ht_rxor_y_hat = ht_predict(ht, test_x_xor,
test_x_rxor)
errors[0, i] = 1 - np.mean(ht_xor_y_hat == test_y_xor)
errors[1, i] = 1 - np.mean(ht_rxor_y_hat == test_y_rxor)
# Mondrian Forest Classifier
if classifiers[1] == 1:
mf.partial_fit(X, y)
mf_xor_y_hat = mf.predict(test_x_xor)
mf_rxor_y_hat = mf.predict(test_x_rxor)
errors[2, i] = 1 - np.mean(mf_xor_y_hat == test_y_xor)
errors[3, i] = 1 - np.mean(mf_rxor_y_hat == test_y_rxor)
# Stream Decision Tree Classifier
if classifiers[2] == 1:
sdt.partial_fit(X, y, classes=[0, 1])
sdt_xor_y_hat = sdt.predict(test_x_xor)
sdt_rxor_y_hat = sdt.predict(test_x_rxor)
errors[4, i] = 1 - np.mean(sdt_xor_y_hat == test_y_xor)
errors[5, i] = 1 - np.mean(sdt_rxor_y_hat == test_y_rxor)
# Stream Decision Forest Classifier
if classifiers[3] == 1:
sdf.partial_fit(X, y, classes=[0, 1])
sdf_xor_y_hat = sdf.predict(test_x_xor)
sdf_rxor_y_hat = sdf.predict(test_x_rxor)
errors[6, i] = 1 - np.mean(sdf_xor_y_hat == test_y_xor)
errors[7, i] = 1 - np.mean(sdf_rxor_y_hat == test_y_rxor)
# Synergistic Forest Classifier
if classifiers[4] == 1:
if i == 0:
synf.add_task(X, y, n_estimators=10, task_id=0)
synf_xor_y_hat = synf.predict(test_x_xor, task_id=0)
elif i < (n_xor / 25):
synf.update_task(X, y, task_id=0)
synf_xor_y_hat = synf.predict(test_x_xor, task_id=0)
elif i == (n_xor / 25):
synf.add_task(X, y, n_estimators=10, task_id=1)
synf_xor_y_hat = synf.predict(test_x_xor, task_id=0)
synf_rxor_y_hat = synf.predict(test_x_rxor, task_id=1)
elif i < (n_xor + n_rxor) / 25:
synf.update_task(X, y, task_id=1)
synf_xor_y_hat = synf.predict(test_x_xor, task_id=0)
synf_rxor_y_hat = synf.predict(test_x_rxor, task_id=1)
elif i < (2 * n_xor + n_rxor) / 25:
synf.update_task(X, y, task_id=0)
synf_xor_y_hat = synf.predict(test_x_xor, task_id=0)
synf_rxor_y_hat = synf.predict(test_x_rxor, task_id=1)
if i < (n_xor / 25):
errors[8, i] = 1 - np.mean(synf_xor_y_hat == test_y_xor)
if i >= (n_xor / 25):
errors[8, i] = 1 - np.mean(synf_xor_y_hat == test_y_xor)
errors[9, i] = 1 - np.mean(synf_rxor_y_hat == test_y_rxor)
return errors
def experiment(
n_task1,
n_task2,
n_test=1000,
task1_angle=0,
task2_angle=np.pi / 2,
n_trees=10,
max_depth=None,
random_state=None,
register=False,
):
"""
A function to do progressive experiment between two tasks
where the task data is generated using Gaussian parity.
Parameters
----------
n_task1 : int
Total number of train sample for task 1.
n_task2 : int
Total number of train dsample for task 2
n_test : int, optional (default=1000)
Number of test sample for each task.
task1_angle : float, optional (default=0)
Angle in radian for task 1.
task2_angle : float, optional (default=numpy.pi/2)
Angle in radian for task 2.
n_trees : int, optional (default=10)
Number of total trees to train for each task.
max_depth : int, optional (default=None)
Maximum allowable depth for each tree.
random_state : int, RandomState instance, default=None
Determines random number generation for dataset creation. Pass an int
for reproducible output across multiple function calls.
Returns
-------
errors : array of shape [6]
Elements of the array is organized as single task error task1,
multitask error task1, single task error task2,
multitask error task2, naive UF error task1,
naive UF task2.
"""
if n_task1 == 0 and n_task2 == 0:
raise ValueError("Wake up and provide samples to train!!!")
if random_state != None:
np.random.seed(random_state)
errors = np.zeros(6, dtype=float)
default_transformer_class = TreeClassificationTransformer
default_transformer_kwargs = {"kwargs": {"max_depth": max_depth}}
default_voter_class = TreeClassificationVoter
default_voter_kwargs = {}
default_decider_class = SimpleArgmaxAverage
default_decider_kwargs = {"classes": np.arange(2)}
progressive_learner = ProgressiveLearner(
default_transformer_class=default_transformer_class,
default_transformer_kwargs=default_transformer_kwargs,
default_voter_class=default_voter_class,
default_voter_kwargs=default_voter_kwargs,
default_decider_class=default_decider_class,
default_decider_kwargs=default_decider_kwargs,
)
uf = ProgressiveLearner(
default_transformer_class=default_transformer_class,
default_transformer_kwargs=default_transformer_kwargs,
default_voter_class=default_voter_class,
default_voter_kwargs=default_voter_kwargs,
default_decider_class=default_decider_class,
default_decider_kwargs=default_decider_kwargs,
)
naive_uf = ProgressiveLearner(
default_transformer_class=default_transformer_class,
default_transformer_kwargs=default_transformer_kwargs,
default_voter_class=default_voter_class,
default_voter_kwargs=default_voter_kwargs,
default_decider_class=default_decider_class,
default_decider_kwargs=default_decider_kwargs,
)
# source data
X_task1, y_task1 = generate_gaussian_parity(n_task1, angle_params=task1_angle)
test_task1, test_label_task1 = generate_gaussian_parity(
n_test, angle_params=task1_angle
)
# target data
X_task2, y_task2 = generate_gaussian_parity(n_task2, angle_params=task2_angle)
test_task2, test_label_task2 = generate_gaussian_parity(
n_test, angle_params=task2_angle
)
if register:
T, X_3, i = icp(X_task2.copy(), X_task1.copy(), y_task2.copy(), y_task1.copy())
X_task2 = X_3.T[:, 0:2]
progressive_learner.add_task(X_task1, y_task1, num_transformers=n_trees)
progressive_learner.add_task(X_task2, y_task2, num_transformers=n_trees)
uf.add_task(X_task1, y_task1, num_transformers=2 * n_trees)
uf.add_task(X_task2, y_task2, num_transformers=2 * n_trees)
uf_task1 = uf.predict(test_task1, transformer_ids=[0], task_id=0)
l2f_task1 = progressive_learner.predict(test_task1, task_id=0)
errors[0] = 1 - np.mean(uf_task1 == test_label_task1)
errors[1] = 1 - np.mean(l2f_task1 == test_label_task1)
return errors