def get(self, name, **kwargs):
"""Retrieves a :py:class:`Parameter` with name ``self.prefix+name``. If not found,
:py:func:`get` will first try to retrieve it from "shared" dict. If still not
found, :py:func:`get` will create a new :py:class:`Parameter` with key-word arguments and
insert it to self.
Parameters
----------
name : str
Name of the desired Parameter. It will be prepended with this dictionary's
prefix.
**kwargs : dict
The rest of key-word arguments for the created :py:class:`Parameter`.
Returns
-------
Parameter
The created or retrieved :py:class:`Parameter`.
"""
name = self.prefix + name
param = self._get_impl(name)
if param is None: # pylint: disable=too-many-nested-blocks
param = Parameter(name, **kwargs)
self._params[name] = param
else:
for k, v in kwargs.items():
if hasattr(param, k) and getattr(param, k) is not None:
existing = getattr(param, k)
if k == 'shape' and len(v) == len(existing):
inferred_shape = []
matched = True
for dim1, dim2 in zip(v, existing):
if dim1 != dim2 and dim1 > 0 and dim2 > 0:
matched = False
break
elif dim1 == dim2:
inferred_shape.append(dim1)
elif dim1 in (
0, -1
): # -1 means unknown dim size in np_shape mode
inferred_shape.append(dim2)
else:
inferred_shape.append(dim1)
if matched:
param._shape = tuple(inferred_shape)
continue
elif k == 'dtype' and anp.dtype(v) == anp.dtype(existing):
continue
assert v is None or v == existing, \
"Cannot retrieve Parameter '%s' because desired attribute " \
"does not match with stored for attribute '%s': " \
"desired '%s' vs stored '%s'."%(
name, k, str(v), str(getattr(param, k)))
else:
setattr(param, k, v)
return param
def fit(self,X,T,ranked_pairs,smoothed_pairs,ranked_pair_weights=None,smoothed_pair_weights=None):
"""
Fit the DSSL loss
Args:
X - (n_samples,n_features) ndarray:
Design matrix
T - (n_samples,) ndarray of:
Vector of continuous timestamps
ranked_pairs - (n_ranked_pairs,2) integer ndarray:
Contains ranked pairs of samples. Model will try to find
parameters such that score(ranked_pairs[i,0]) > score(ranked_pairs[i,1])
for all i.
smoothed_pairs - (n_smoothed_pairs,2) integer ndarray:
Contains pairs of samples that are close in time. Model will
try to find parameters such that minimizes
(score(ranked_pairs[i,0]) - score(ranked_pairs[i,1]))**2/(T(ranked_pairs[i,0]) - T(ranked_pairs[i,1]))**2
for all i.
ranked_pair_weights - (n_ranked_pairs,) float ndarray:
Contains sample weights for each of the ranked pairs.
smoothed_pair_weights - (n_smoothed_pairs,) float ndarray:
Contains sample weights for each of the smoothed pairs.
"""
assert X.shape[0] > 0
assert T.shape == (X.shape[0],)
assert ranked_pairs is None or np.issubdtype(ranked_pairs.dtype, np.dtype(int).type)
assert smoothed_pairs is None or np.issubdtype(smoothed_pairs.dtype, np.dtype(int).type)
assert ranked_pairs is None or np.all(np.logical_and(ranked_pairs >= 0,ranked_pairs <= X.shape[0]))
assert smoothed_pairs is None or np.all(np.logical_and(smoothed_pairs >= 0,smoothed_pairs <= X.shape[0]))
assert ranked_pairs is None or np.all(ranked_pairs[:,0] != ranked_pairs[:,1])
assert smoothed_pairs is None or np.all(smoothed_pairs[:,0] != smoothed_pairs[:,1])
# get obj
obj = self.get_obj(X,T,ranked_pairs,smoothed_pairs,ranked_pair_weights,smoothed_pair_weights)
# get the gradient function using autograd
gfun = grad(obj)
# init params
w0 = np.zeros(X.shape[1])
# optimize objective
self.res = minimize(obj,w0,method="L-BFGS-B",jac=gfun,options={"gtol":self.gtol,"maxiter":self.maxiter,"disp":self.disp},tol=self.tol)
self.set_params(self.res.x)
return self
def test_astype():
x = np.arange(3, dtype='float32')
def f(x):
return np.sum(np.sin(x.astype('float64')))
assert grad(f)(x).dtype == np.dtype('float32')
def _read32(bytestream):
dt = np.dtype(np.uint32).newbyteorder('>')
return np.frombuffer(bytestream.read(4), dtype=dt)[0]
def one_hot(labels, num_classes):
return np.eye(num_classes, dtype=np.dtype("uint8"))[labels]
dtype, einsum, empty, empty_like, equal, exp, expand_dims, eye, flip,
float32, float64, floor, greater, hsplit, hstack, int32, int64, isclose,
isnan, less, less_equal, linspace, log, logical_and, logical_or, matmul,
maximum, mean, meshgrid, mod, ones, ones_like, outer, power, repeat,
reshape, shape, sign, sin, sinh, split, sqrt, squeeze, stack, std, sum,
tan, tanh, tile, trace, transpose, triu_indices, tril_indices,
searchsorted, tril, uint8, vstack, where, zeros, zeros_like)
from autograd.scipy.special import polygamma # NOQA
from scipy.sparse import coo_matrix
from . import linalg # NOQA
from . import random # NOQA
from .common import to_ndarray # NOQA
DTYPES = {
dtype('int32'): 0,
dtype('int64'): 1,
dtype('float32'): 2,
dtype('float64'): 3
}
def to_numpy(x):
return x
def convert_to_wider_dtype(tensor_list):
dtype_list = [DTYPES[x.dtype] for x in tensor_list]
wider_dtype_index = max(dtype_list)
wider_dtype = list(DTYPES.keys())[wider_dtype_index]
def read_int32(f):
return np.fromstring(f.read(4), dtype=np.dtype('>i4'))[0]
def read_int32(f):
return np.fromstring(f.read(4), dtype=np.dtype('>i4'))[0]
