def generate_graph(w_vec_list=None):
interval_for_plot = []
np.random.seed(seed=SEED_)
pos_data_points, neg_data_points = rand_point_generator(point_num=50)
rotation_matrix = get_transformation(angle=ANGLE_)
pos_transformed = np.dot(pos_data_points[:, 0:2], rotation_matrix)
neg_transformed = np.dot(neg_data_points[:, 0:2], rotation_matrix)
fig = plt.figure(1)
plt.scatter([x[0] for x in pos_transformed],
[x[1] for x in pos_transformed],
c='r',
marker='^')
plt.scatter([x[0] for x in neg_transformed],
[x[1] for x in neg_transformed],
c='b',
marker='^')
# plt.scatter([x[0] for x in pos_data_points], [x[1] for x in pos_data_points], c='r')
# plt.scatter([x[0] for x in neg_data_points], [x[1] for x in neg_data_points], c='b')
interval_for_plot = np.arange(-2, 3)
for vec_idx_, w_ in enumerate(w_vec_list):
w_transformed = np.transpose(np.dot(np.transpose(w_), rotation_matrix))
x_table_tmp = []
y_table_tmp = []
for points in interval_for_plot:
x_table_tmp.append(points * w_transformed[0])
y_table_tmp.append(points * w_transformed[1])
plt.plot(x_table_tmp, y_table_tmp)
plt.show()
def logistic_loss_1(w):
'''
x is the fake dataset wrapped with labels
in this quite simple example we just have two data points
in our set x
update to test metric 2 for more specific relationship between hessian and margin
input:
x = np.array([2, 0, 0])
output:
loss values
'''
tmp_loss = 0
# x = np.array([[0, 2, 1], [2, 0, 0]])
# x = np.array([[2, 0, -1]])
# x = np.array([[1, -1, -1]])
np.random.seed(seed=SEED_)
_, neg_data_points = rand_point_generator(point_num=50)
x = neg_data_points
for idx, data_vec in enumerate(x):
tmp_loss += math.log(1 +
math.exp(-data_vec[-1] *
np.dot(np.transpose(w), data_vec[0:-1])))
return 1 / float(x.shape[0]) * tmp_loss
def logcosh(w):
'''a new kind of loss here'''
tmp_loss = 0
# X = np.array([[0, 2, 1], [2, 0, 0]])
# X = np.array([[0, 2, 1], [2, 0, -1]])
np.random.seed(seed=SEED_)
pos_data_points, neg_data_points = rand_point_generator(point_num=50)
X = np.concatenate((pos_data_points, neg_data_points), axis=0)
for idx, data_vec in enumerate(X):
tmp_loss += math.log(
cosh(np.dot(np.transpose(w), data_vec[0:-1]) - data_vec[-1]))
return 1 / float(X.shape[0]) * tmp_loss
def generate_graph(w_vec_list=None):
interval_for_plot = []
np.random.seed(seed=SEED_)
pos_data_points, neg_data_points = rand_point_generator(point_num=50)
fig = plt.figure(1)
plt.scatter([x[0] for x in pos_data_points],
[x[1] for x in pos_data_points],
c='r')
plt.scatter([x[0] for x in neg_data_points],
[x[1] for x in neg_data_points],
c='b')
interval_for_plot = np.arange(-2, 50)
for vec_idx_, w_ in enumerate(w_vec_list):
x_table_tmp = []
y_table_tmp = []
for points in interval_for_plot:
x_table_tmp.append(points * w_[0])
y_table_tmp.append(points * w_[1])
plt.plot(x_table_tmp, y_table_tmp)
plt.show()
def logistic_loss(w):
'''x is the fake dataset wrapped with labels
in this quite simple example we just have two data points
in our set x
input:
x = np.array([0, 2, 1], [2, 0, 0])
output:
loss values
'''
tmp_loss = 0
# x = np.array([[0, 2, 1], [2, 0, 0]])
# x = np.array([[0, 2, 1], [2, 0, -1]])
# x = np.array([[-0.5, 1, 1], [0.7, -0.5, -1]])
np.random.seed(seed=SEED_)
pos_data_points, neg_data_points = rand_point_generator(point_num=50)
rotation_matrix = get_transformation(angle=ANGLE_)
pos_transformed = np.dot(pos_data_points[:, 0:2], rotation_matrix)
neg_transformed = np.dot(neg_data_points[:, 0:2], rotation_matrix)
x = np.concatenate((pos_transformed, neg_transformed), axis=0)
x_new = np.zeros((x.shape[0], 3))
for idx_x_p, x_p in enumerate(x):
if idx_x_p <= 49:
x_new[idx_x_p] = np.append(x_p, 1)
else:
x_new[idx_x_p] = np.append(x_p, -1)
#x_ = np.concatenate((pos_data_points, neg_data_points), axis=0)
#y_ = x[:,-1]
for idx, data_vec in enumerate(x_new):
tmp_loss += math.log(1 +
math.exp(-data_vec[-1] *
np.dot(np.transpose(w), data_vec[0:-1])))
# tmp_loss += math.log(1+math.exp(-y_[idx]*np.dot(np.transpose(w),data_vec)))
return 1 / float(x.shape[0]) * tmp_loss
def logistic_loss(w):
'''x is the fake dataset wrapped with labels
in this quite simple example we just have two data points
in our set x
input:
x = np.array([0, 2, 1], [2, 0, 0])
output:
loss values
'''
tmp_loss = 0
# x = np.array([[0, 2, 1], [2, 0, 0]])
# x = np.array([[0, 2, 1], [2, 0, -1]])
# x = np.array([[-0.5, 1, 1], [0.7, -0.5, -1]])
np.random.seed(seed=SEED_)
pos_data_points, neg_data_points = rand_point_generator(point_num=50)
x = np.concatenate((pos_data_points, neg_data_points), axis=0)
for idx, data_vec in enumerate(x):
tmp_loss += math.log(1 +
math.exp(-data_vec[-1] *
np.dot(np.transpose(w), data_vec[0:-1])))
return 1 / float(x.shape[0]) * tmp_loss
def logcosh(w):
'''a new kind of loss here'''
tmp_loss = 0
# X = np.array([[0, 2, 1], [2, 0, 0]])
# X = np.array([[0, 2, 1], [2, 0, -1]])
np.random.seed(seed=SEED_)
pos_data_points, neg_data_points = rand_point_generator(point_num=50)
# X = np.concatenate((pos_data_points, neg_data_points), axis=0)
rotation_matrix = get_transformation(angle=ANGLE_)
pos_transformed = np.dot(pos_data_points[:, 0:2], rotation_matrix)
neg_transformed = np.dot(neg_data_points[:, 0:2], rotation_matrix)
X = np.concatenate((pos_transformed, neg_transformed), axis=0)
X_new = np.zeros((X.shape[0], 3))
for idx_x_p, x_p in enumerate(X):
if idx_x_p <= 49:
X_new[idx_x_p] = np.append(x_p, 1)
else:
X_new[idx_x_p] = np.append(x_p, -1)
for idx, data_vec in enumerate(X_new):
tmp_loss += math.log(
cosh(np.dot(np.transpose(w), data_vec[0:-1]) - data_vec[-1]))
return 1 / float(X.shape[0]) * tmp_loss
def log_loss(w):
"""Log loss, aka logistic loss or cross-entropy loss.
This is the loss function used in (multinomial) logistic regression
and extensions of it such as neural networks, defined as the negative
log-likelihood of the true labels given a probabilistic classifier's
predictions. The log loss is only defined for two or more labels.
For a single sample with true label yt in {0,1} and
estimated probability yp that yt = 1, the log loss is
-log P(yt|yp) = -(yt log(yp) + (1 - yt) log(1 - yp))
Read more in the :ref:`User Guide <log_loss>`.
Parameters
----------
y_true : array-like or label indicator matrix
Ground truth (correct) labels for n_samples samples.
y_pred : array-like of float, shape = (n_samples, n_classes) or (n_samples,)
Predicted probabilities, as returned by a classifier's
predict_proba method. If ``y_pred.shape = (n_samples,)``
the probabilities provided are assumed to be that of the
positive class. The labels in ``y_pred`` are assumed to be
ordered alphabetically, as done by
:class:`preprocessing.LabelBinarizer`.
eps : float
Log loss is undefined for p=0 or p=1, so probabilities are
clipped to max(eps, min(1 - eps, p)).
normalize : bool, optional (default=True)
If true, return the mean loss per sample.
Otherwise, return the sum of the per-sample losses.
sample_weight : array-like of shape = [n_samples], optional
Sample weights.
labels : array-like, optional (default=None)
If not provided, labels will be inferred from y_true. If ``labels``
is ``None`` and ``y_pred`` has shape (n_samples,) the labels are
assumed to be binary and are inferred from ``y_true``.
.. versionadded:: 0.18
Returns
-------
loss : float
Examples
--------
>>> log_loss(["spam", "ham", "ham", "spam"], # doctest: +ELLIPSIS
... [[.1, .9], [.9, .1], [.8, .2], [.35, .65]])
0.21616...
References
----------
C.M. Bishop (2006). Pattern Recognition and Machine Learning. Springer,
p. 209.
Notes
-----
The logarithm used is the natural logarithm (base-e).
"""
# do this hack for hessian computation
eps = 1e-15
normalize = True
sample_weight = None
labels = None
# define labels here
np.random.seed(seed=SEED_)
pos_data_points, neg_data_points = rand_point_generator(point_num=50)
#==================================================================
rotation_matrix = get_transformation(angle=ANGLE_)
pos_transformed = np.dot(pos_data_points[:, 0:2], rotation_matrix)
neg_transformed = np.dot(neg_data_points[:, 0:2], rotation_matrix)
#==================================================================
dataset = np.concatenate((pos_data_points, neg_data_points), axis=0)
X = np.concatenate((pos_transformed, neg_transformed), axis=0)
#X = dataset[:, 0:2]
y_true = dataset[:, -1]
# X = np.array([[0,2], [2, 0]])
# y_true=np.array([1,0])
# y_true=np.array([1,-1])
y_pred = np.zeros(X.shape[0])
for i in range(X.shape[0]):
y_pred[i] = np.dot(np.transpose(w), X[i])
y_pred = check_array(y_pred, ensure_2d=False)
check_consistent_length(y_pred, y_true)
lb = LabelBinarizer()
if labels is not None:
lb.fit(labels)
else:
lb.fit(y_true)
if len(lb.classes_) == 1:
if labels is None:
raise ValueError('y_true contains only one label ({0}). Please '
'provide the true labels explicitly through the '
'labels argument.'.format(lb.classes_[0]))
else:
raise ValueError('The labels array needs to contain at least two '
'labels for log_loss, '
'got {0}.'.format(lb.classes_))
transformed_labels = lb.transform(y_true)
if transformed_labels.shape[1] == 1:
transformed_labels = np.append(1 - transformed_labels,
transformed_labels,
axis=1)
# Clipping
y_pred = np.clip(y_pred, eps, 1 - eps)
# If y_pred is of single dimension, assume y_true to be binary
# and then check.
if y_pred.ndim == 1:
y_pred = y_pred[:, np.newaxis]
if y_pred.shape[1] == 1:
y_pred = np.append(1 - y_pred, y_pred, axis=1)
# Check if dimensions are consistent.
transformed_labels = check_array(transformed_labels)
if len(lb.classes_) != y_pred.shape[1]:
if labels is None:
raise ValueError("y_true and y_pred contain different number of "
"classes {0}, {1}. Please provide the true "
"labels explicitly through the labels argument. "
"Classes found in "
"y_true: {2}".format(transformed_labels.shape[1],
y_pred.shape[1],
lb.classes_))
else:
raise ValueError('The number of classes in labels is different '
'from that in y_pred. Classes found in '
'labels: {0}'.format(lb.classes_))
# Renormalize
y_pred /= y_pred.sum(axis=1)[:, np.newaxis]
loss = -(transformed_labels * np.log(y_pred)).sum(axis=1)
return _weighted_sum(loss, sample_weight, normalize)
plt.show()
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument('-m',
'--mode',
help='mode of this program',
required=True,
dest='mode')
argument = parser.parse_args()
mode = argument.mode
# get the random dataset:
np.random.seed(seed=SEED_)
pos_data_points, neg_data_points = rand_point_generator(point_num=50)
dataset = np.concatenate((pos_data_points, neg_data_points), axis=0)
X = dataset[:, 0:2]
y = dataset[:, -1]
rotation_matrix = get_transformation(angle=ANGLE_)
X_transformed = np.dot(X, rotation_matrix)
# do some test here if under debug mode
if mode == "debug":
w, w_fake = find_hyperplane_vector(angle=2 * math.pi / 8)
w_2, w_2_fake = find_hyperplane_vector(angle=math.pi / 3)
H = nd.Hessian(logcosh)([float(w[0]), float(w[1])])
print(np.linalg.eig(H)[0])
interval_for_plot = []
for i in range(-2, 3):
interval_for_plot.append([i, 0])