def activate(inputs, mode, lower, upper): if mode == 'relu': return np.maximum(Number(0.0), inputs) elif mode == 'drelu': return np.minimum(upper, np.maximum(lower, inputs)) else: print 'Not Supported'
def forward(self, X): """Forward pass to obtain the action probabilities for each observation in `X`.""" a = np.dot(self.params['w1'], X.T) h = np.maximum(0, a) logits = np.dot(h.T, self.params['w2'].T) p = 1.0 / (1.0 + np.exp(-logits)) return p
def svm_loss(x, y): """ Computes the loss and gradient using for multiclass SVM classification. Inputs: - x: Input data, of shape (N, C) where x[i, j] is the score for the jth class for the ith input. - y: Vector of labels, of shape (N,) where y[i] is the label for x[i] and 0 <= y[i] < C Returns a tuple of: - loss: Scalar giving the loss - dx: Gradient of the loss with respect to x """ N = x.shape[0] correct_class_scores = x[np.arange(N), y] #TODO: Support broadcast case: (X,) (X, Y) #shape(x) is (d0, d1) #shape(correct_class_scores) is (d0,) #margins = np.maximum(0, x - correct_class_scores + 1.0) margins = np.transpose(np.maximum(0, np.transpose(x) - np.transpose(correct_class_scores) + 1.0)) loss = (np.sum(margins) - np.sum(margins[np.arange(N), y])) / N return loss
def loss(self, ps, as_, vs, rs, advs): ps = np.maximum(1.0e-5, np.minimum(1.0 - 1e-5, ps)) policy_grad_loss = -np.sum(np.log(ps) * as_ * advs) vf_loss = 0.5*np.sum((vs - rs)**2) entropy = -np.sum(ps*np.log(ps)) loss_ = policy_grad_loss + self.config.vf_wt*vf_loss - self.config.entropy_wt*entropy return loss_
def svm_loss(x, y): """ Computes the loss and gradient using for multiclass SVM classification. Inputs: - x: Input data, of shape (N, C) where x[i, j] is the score for the jth class for the ith input. - y: Vector of labels, of shape (N,) where y[i] is the label for x[i] and 0 <= y[i] < C Returns a tuple of: - loss: Scalar giving the loss - dx: Gradient of the loss with respect to x """ N = x.shape[0] correct_class_scores = x[np.arange(N), y] #TODO: Support broadcast case: (X,) (X, Y) #shape(x) is (d0, d1) #shape(correct_class_scores) is (d0,) #margins = np.maximum(0, x - correct_class_scores + 1.0) margins = np.transpose( np.maximum(0, np.transpose(x) - np.transpose(correct_class_scores) + 1.0)) loss = (np.sum(margins) - np.sum(margins[np.arange(N), y])) / N return loss
def svm_loss(x, y, mode): """ Computes the loss and gradient using for multiclass SVM classification. Inputs: - x: Input data, of shape (N, C) where x[i, j] is the score for the jth class for the ith input. - y: Vector of labels, of shape (N,) where y[i] is the label for x[i] and 0 <= y[i] < C Returns a tuple of: - loss: Scalar giving the loss - dx: Gradient of the loss with respect to x """ if mode == 'cpu': np.set_policy(policy.OnlyNumpyPolicy()) else: np.set_policy(policy.PreferMXNetPolicy()) N = x.shape[0] correct_class_scores = x[np.arange(N), y] #margins = np.maximum(0, x - correct_class_scores[:, np.newaxis] + 1.0) margins = np.maximum(0, x - np.expand_dims(correct_class_scores, axis = 1) + 1.0) margins[np.arange(N), y] = 0 loss = np.sum(margins) / N num_pos = np.sum(margins > 0, axis=1) dx = np.zeros_like(x) dx[margins > 0] = 1 dx[np.arange(N), y] -= num_pos dx /= N return loss, dx
def rel_error(x, y): """Returns relative error""" if isinstance(x, (int, float, Number)): x = float(x) y = float(y) return abs(x - y) / max(1e-8, abs(x) + abs(y)) else: return np.max(np.abs(x - y) / (np.maximum(1e-8, np.abs(x) + np.abs(y))))
def forward(self, X): a = np.dot(self.params['fc1'], X.T) h = np.maximum(0, a) logits = np.dot(h.T, self.params['policy_fc_last'].T) ps = np.exp(logits - np.max(logits, axis=1, keepdims=True)) ps /= np.sum(ps, axis=1, keepdims=True) vs = np.dot(h.T, self.params['vf_fc_last'].T) + self.params['vf_fc_last_bias'] return ps, vs
def test_operations(): a = np.ones((2, 3)) b = np.ones((2, 3)) c = a + b d = -c print(d) e = np.sin(c**2).T print(e) f = np.maximum(a, c) print(f)
def relu(x): """ Computes the forward pass for a layer of rectified linear units (ReLUs). Input: - x: Inputs, of any shape Returns a tuple of: - out: Output, of the same shape as x """ out = np.maximum(0, x) return out
def svm_loss(x, y, mode): """ Computes the loss and gradient using for multiclass SVM classification. Inputs: - x: Input data, of shape (N, C) where x[i, j] is the score for the jth class for the ith input. - y: Vector of labels, of shape (N,) where y[i] is the label for x[i] and 0 <= y[i] < C Returns a tuple of: - loss: Scalar giving the loss - dx: Gradient of the loss with respect to x """ if mode == 'cpu': np.set_policy(policy.OnlyNumpyPolicy()) else: np.set_policy(policy.PreferMXNetPolicy()) N = x.shape[0] correct_class_scores = x[np.arange(N), y] #TODO: Support broadcast case: (X,) (X, Y) #margins = np.maximum(0, x - correct_class_scores + 1.0) margins = np.transpose( np.maximum(0, np.transpose(x) - np.transpose(correct_class_scores) + 1.0)) #margins[np.arange(N), y] = 0 #loss = np.sum(margins) / N loss = (np.sum(margins) - np.sum(margins[np.arange(N), y])) / N margins[np.arange(N), y] = 0 num_pos = np.sum(margins > 0, axis=1) dx = np.zeros_like(x) dx[margins > 0] = 1 dx[np.arange(N), y] -= num_pos dx /= N return loss, dx
def initial_point_reward(self, loc): line_width = int(config['target_line_width'] / 2) distance = config['forward_distance'] long_width = line_width + distance left_idx = [-line_width, long_width, -line_width, line_width] right_idx = [-long_width, line_width, -line_width, line_width] down_idx = [-line_width, line_width, -line_width, long_width] up_idx = [-line_width, line_width, -long_width, line_width] base = np.array([loc[0], loc[0], loc[1], loc[1]]) idxs = np.array([left_idx, right_idx, down_idx, up_idx]) for i in range(len(idxs)): idxs[i] = np.minimum( np.maximum(idxs[i] + base, 0), [self.width, self.width, self.height, self.height]) target_direction = self.count_not_target_points(idxs) if target_direction == 0: return -300 elif target_direction == 1: return 300 elif target_direction == 2: return 0 elif target_direction > 2: return -200
def loss(self, ps, ys, rs): # Prevent log of zero. ps = np.maximum(1.0e-5, np.minimum(1.0 - 1e-5, ps)) step_losses = ys * np.log(ps) + (1.0 - ys) * np.log(1.0 - ps) return -np.sum(step_losses * rs)
def clip(X, lower, upper): return np.minimum(upper, np.maximum(lower, X))
def test_ufunc(): x = np.array([-1.2, 1.2]) np.absolute(x) np.absolute(1.2 + 1j) x = np.linspace(start=-10, stop=10, num=101) np.add(1.0, 4.0) x1 = np.arange(9.0).reshape((3, 3)) x2 = np.arange(3.0) np.add(x1, x2) np.arccos([1, -1]) x = np.linspace(-1, 1, num=100) np.arccosh([np.e, 10.0]) np.arccosh(1) np.arcsin(0) np.arcsinh(np.array([np.e, 10.0])) np.arctan([0, 1]) np.pi/4 x = np.linspace(-10, 10) x = np.array([-1, +1, +1, -1]) y = np.array([-1, -1, +1, +1]) np.arctan2(y, x) * 180 / np.pi np.arctan2([1., -1.], [0., 0.]) np.arctan2([0., 0., np.inf], [+0., -0., np.inf]) np.arctanh([0, -0.5]) np.bitwise_and(13, 17) np.bitwise_and(14, 13) # np.binary_repr(12) return str np.bitwise_and([14,3], 13) np.bitwise_and([11,7], [4,25]) np.bitwise_and(np.array([2,5,255]), np.array([3,14,16])) np.bitwise_and([True, True], [False, True]) np.bitwise_or(13, 16) # np.binary_repr(29) np.bitwise_or(32, 2) np.bitwise_or([33, 4], 1) np.bitwise_or([33, 4], [1, 2]) np.bitwise_or(np.array([2, 5, 255]), np.array([4, 4, 4])) # np.array([2, 5, 255]) | np.array([4, 4, 4]) np.bitwise_or(np.array([2, 5, 255, 2147483647], dtype=np.int32), np.array([4, 4, 4, 2147483647], dtype=np.int32)) np.bitwise_or([True, True], [False, True]) np.bitwise_xor(13, 17) # np.binary_repr(28) np.bitwise_xor(31, 5) np.bitwise_xor([31,3], 5) np.bitwise_xor([31,3], [5,6]) np.bitwise_xor([True, True], [False, True]) a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]) np.ceil(a) a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]) np.trunc(a) np.cos(np.array([0, np.pi/2, np.pi])) np.cosh(0) x = np.linspace(-4, 4, 1000) rad = np.arange(12.)*np.pi/6 np.degrees(rad) out = np.zeros((rad.shape)) r = np.degrees(rad, out) # np.all(r == out) return bool np.rad2deg(np.pi/2) np.divide(2.0, 4.0) x1 = np.arange(9.0).reshape((3, 3)) x2 = np.arange(3.0) np.divide(2, 4) np.divide(2, 4.) np.equal([0, 1, 3], np.arange(3)) np.equal(1, np.ones(1)) x = np.linspace(-2*np.pi, 2*np.pi, 100) np.exp2([2, 3]) np.expm1(1e-10) np.exp(1e-10) - 1 np.fabs(-1) np.fabs([-1.2, 1.2]) a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]) np.floor(a) np.floor_divide(7,3) np.floor_divide([1., 2., 3., 4.], 2.5) np.fmod([-3, -2, -1, 1, 2, 3], 2) np.remainder([-3, -2, -1, 1, 2, 3], 2) np.fmod([5, 3], [2, 2.]) a = np.arange(-3, 3).reshape(3, 2) np.fmod(a, [2,2]) np.greater([4,2],[2,2]) a = np.array([4,2]) b = np.array([2,2]) a > b np.greater_equal([4, 2, 1], [2, 2, 2]) np.hypot(3*np.ones((3, 3)), 4*np.ones((3, 3))) np.hypot(3*np.ones((3, 3)), [4]) np.bitwise_not is np.invert np.invert(np.array([13], dtype=np.uint8)) # np.binary_repr(242, width=8) np.invert(np.array([13], dtype=np.uint16)) np.invert(np.array([13], dtype=np.int8)) # np.binary_repr(-14, width=8) np.invert(np.array([True, False])) # np.isfinite(1) # np.isfinite(0) # np.isfinite(np.nan) # np.isfinite(np.inf) # np.isfinite(np.NINF) x = np.array([-np.inf, 0., np.inf]) y = np.array([2, 2, 2]) np.isfinite(x, y) # np.isinf(np.inf) # np.isinf(np.nan) # np.isinf(np.NINF) # np.isinf([np.inf, -np.inf, 1.0, np.nan]) x = np.array([-np.inf, 0., np.inf]) y = np.array([2, 2, 2]) # np.isinf(x, y) # np.isnan(np.nan) # np.isnan(np.inf) # np.binary_repr(5) np.left_shift(5, 2) # np.binary_repr(20) np.left_shift(5, [1,2,3]) np.less([1, 2], [2, 2]) np.less_equal([4, 2, 1], [2, 2, 2]) x = np.array([0, 1, 2, 2**4]) xi = np.array([0+1.j, 1, 2+0.j, 4.j]) np.log2(xi) prob1 = np.log(1e-50) prob2 = np.log(2.5e-50) prob12 = np.logaddexp(prob1, prob2) prob12 np.exp(prob12) prob1 = np.log2(1e-50) prob2 = np.log2(2.5e-50) prob12 = np.logaddexp2(prob1, prob2) prob1, prob2, prob12 2**prob12 np.log1p(1e-99) np.log(1 + 1e-99) # np.logical_and(True, False) # np.logical_and([True, False], [False, False]) x = np.arange(5) # np.logical_and(x>1, x<4) # np.logical_not(3) # np.logical_not([True, False, 0, 1]) x = np.arange(5) # np.logical_not(x<3) # np.logical_or(True, False) # np.logical_or([True, False], [False, False]) x = np.arange(5) # np.logical_or(x < 1, x > 3) # np.logical_xor(True, False) # np.logical_xor([True, True, False, False], [True, False, True, False]) x = np.arange(5) # np.logical_xor(x < 1, x > 3) # np.logical_xor(0, np.eye(2)) np.maximum([2, 3, 4], [1, 5, 2]) # np.maximum([np.nan, 0, np.nan], [0, np.nan, np.nan]) # np.maximum(np.Inf, 1) np.minimum([2, 3, 4], [1, 5, 2]) # np.minimum([np.nan, 0, np.nan],[0, np.nan, np.nan]) # np.minimum(-np.Inf, 1) np.fmax([2, 3, 4], [1, 5, 2]) np.fmax(np.eye(2), [0.5, 2]) # np.fmax([np.nan, 0, np.nan],[0, np.nan, np.nan]) np.fmin([2, 3, 4], [1, 5, 2]) np.fmin(np.eye(2), [0.5, 2]) # np.fmin([np.nan, 0, np.nan],[0, np.nan, np.nan]) np.modf([0, 3.5]) np.modf(-0.5) np.multiply(2.0, 4.0) x1 = np.arange(9.0).reshape((3, 3)) x2 = np.arange(3.0) np.multiply(x1, x2) np.negative([1.,-1.]) np.not_equal([1.,2.], [1., 3.]) np.not_equal([1, 2], [[1, 3],[1, 4]]) x1 = range(6) np.power(x1, 3) x2 = [1.0, 2.0, 3.0, 3.0, 2.0, 1.0] np.power(x1, x2) x2 = np.array([[1, 2, 3, 3, 2, 1], [1, 2, 3, 3, 2, 1]]) np.power(x1, x2) deg = np.arange(12.) * 30. np.radians(deg) out = np.zeros((deg.shape)) ret = np.radians(deg, out) ret is out np.deg2rad(180) np.reciprocal(2.) np.reciprocal([1, 2., 3.33]) np.remainder([4, 7], [2, 3]) np.remainder(np.arange(7), 5) # np.binary_repr(10) np.right_shift(10, 1) # np.binary_repr(5) np.right_shift(10, [1,2,3]) a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]) np.rint(a) np.sign([-5., 4.5]) np.sign(0) # np.sign(5-2j) # np.signbit(-1.2) np.signbit(np.array([1, -2.3, 2.1])) np.copysign(1.3, -1) np.copysign([-1, 0, 1], -1.1) np.copysign([-1, 0, 1], np.arange(3)-1) np.sin(np.pi/2.) np.sin(np.array((0., 30., 45., 60., 90.)) * np.pi / 180. ) x = np.linspace(-np.pi, np.pi, 201) np.sinh(0) # np.sinh(np.pi*1j/2) np.sqrt([1,4,9]) np.sqrt([4, -1, -3+4J]) np.cbrt([1,8,27]) np.square([-1j, 1]) np.subtract(1.0, 4.0) x1 = np.arange(9.0).reshape((3, 3)) x2 = np.arange(3.0) np.subtract(x1, x2) np.tan(np.array([-pi,pi/2,pi])) np.tanh((0, np.pi*1j, np.pi*1j/2)) x = np.arange(5) np.true_divide(x, 4) x = np.arange(9) y1, y2 = np.frexp(x) y1 * 2**y2 np.ldexp(5, np.arange(4)) x = np.arange(6) np.ldexp(*np.frexp(x))
def forward(self, inputs, parameters): lower = parameters[self._lower] upper = parameters[self._upper] return np.minimum(upper, np.maximum(lower, inputs))
def test_ufunc(): x = np.array([-1.2, 1.2]) np.absolute(x) np.absolute(1.2 + 1j) x = np.linspace(start=-10, stop=10, num=101) np.add(1.0, 4.0) x1 = np.arange(9.0).reshape((3, 3)) x2 = np.arange(3.0) np.add(x1, x2) np.arccos([1, -1]) x = np.linspace(-1, 1, num=100) np.arccosh([np.e, 10.0]) np.arccosh(1) np.arcsin(0) np.arcsinh(np.array([np.e, 10.0])) np.arctan([0, 1]) np.pi / 4 x = np.linspace(-10, 10) x = np.array([-1, +1, +1, -1]) y = np.array([-1, -1, +1, +1]) np.arctan2(y, x) * 180 / np.pi np.arctan2([1., -1.], [0., 0.]) np.arctan2([0., 0., np.inf], [+0., -0., np.inf]) np.arctanh([0, -0.5]) np.bitwise_and(13, 17) np.bitwise_and(14, 13) # np.binary_repr(12) return str np.bitwise_and([14, 3], 13) np.bitwise_and([11, 7], [4, 25]) np.bitwise_and(np.array([2, 5, 255]), np.array([3, 14, 16])) np.bitwise_and([True, True], [False, True]) np.bitwise_or(13, 16) # np.binary_repr(29) np.bitwise_or(32, 2) np.bitwise_or([33, 4], 1) np.bitwise_or([33, 4], [1, 2]) np.bitwise_or(np.array([2, 5, 255]), np.array([4, 4, 4])) # np.array([2, 5, 255]) | np.array([4, 4, 4]) np.bitwise_or(np.array([2, 5, 255, 2147483647], dtype=np.int32), np.array([4, 4, 4, 2147483647], dtype=np.int32)) np.bitwise_or([True, True], [False, True]) np.bitwise_xor(13, 17) # np.binary_repr(28) np.bitwise_xor(31, 5) np.bitwise_xor([31, 3], 5) np.bitwise_xor([31, 3], [5, 6]) np.bitwise_xor([True, True], [False, True]) a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]) np.ceil(a) a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]) np.trunc(a) np.cos(np.array([0, np.pi / 2, np.pi])) np.cosh(0) x = np.linspace(-4, 4, 1000) rad = np.arange(12.) * np.pi / 6 np.degrees(rad) out = np.zeros((rad.shape)) r = np.degrees(rad, out) # np.all(r == out) return bool np.rad2deg(np.pi / 2) np.divide(2.0, 4.0) x1 = np.arange(9.0).reshape((3, 3)) x2 = np.arange(3.0) np.divide(2, 4) np.divide(2, 4.) np.equal([0, 1, 3], np.arange(3)) np.equal(1, np.ones(1)) x = np.linspace(-2 * np.pi, 2 * np.pi, 100) np.exp2([2, 3]) np.expm1(1e-10) np.exp(1e-10) - 1 np.fabs(-1) np.fabs([-1.2, 1.2]) a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]) np.floor(a) np.floor_divide(7, 3) np.floor_divide([1., 2., 3., 4.], 2.5) np.fmod([-3, -2, -1, 1, 2, 3], 2) np.remainder([-3, -2, -1, 1, 2, 3], 2) np.fmod([5, 3], [2, 2.]) a = np.arange(-3, 3).reshape(3, 2) np.fmod(a, [2, 2]) np.greater([4, 2], [2, 2]) a = np.array([4, 2]) b = np.array([2, 2]) a > b np.greater_equal([4, 2, 1], [2, 2, 2]) np.hypot(3 * np.ones((3, 3)), 4 * np.ones((3, 3))) np.hypot(3 * np.ones((3, 3)), [4]) np.bitwise_not is np.invert np.invert(np.array([13], dtype=np.uint8)) # np.binary_repr(242, width=8) np.invert(np.array([13], dtype=np.uint16)) np.invert(np.array([13], dtype=np.int8)) # np.binary_repr(-14, width=8) np.invert(np.array([True, False])) # np.isfinite(1) # np.isfinite(0) # np.isfinite(np.nan) # np.isfinite(np.inf) # np.isfinite(np.NINF) x = np.array([-np.inf, 0., np.inf]) y = np.array([2, 2, 2]) np.isfinite(x, y) # np.isinf(np.inf) # np.isinf(np.nan) # np.isinf(np.NINF) # np.isinf([np.inf, -np.inf, 1.0, np.nan]) x = np.array([-np.inf, 0., np.inf]) y = np.array([2, 2, 2]) # np.isinf(x, y) # np.isnan(np.nan) # np.isnan(np.inf) # np.binary_repr(5) np.left_shift(5, 2) # np.binary_repr(20) np.left_shift(5, [1, 2, 3]) np.less([1, 2], [2, 2]) np.less_equal([4, 2, 1], [2, 2, 2]) x = np.array([0, 1, 2, 2**4]) xi = np.array([0 + 1.j, 1, 2 + 0.j, 4.j]) np.log2(xi) prob1 = np.log(1e-50) prob2 = np.log(2.5e-50) prob12 = np.logaddexp(prob1, prob2) prob12 np.exp(prob12) prob1 = np.log2(1e-50) prob2 = np.log2(2.5e-50) prob12 = np.logaddexp2(prob1, prob2) prob1, prob2, prob12 2**prob12 np.log1p(1e-99) np.log(1 + 1e-99) # np.logical_and(True, False) # np.logical_and([True, False], [False, False]) x = np.arange(5) # np.logical_and(x>1, x<4) # np.logical_not(3) # np.logical_not([True, False, 0, 1]) x = np.arange(5) # np.logical_not(x<3) # np.logical_or(True, False) # np.logical_or([True, False], [False, False]) x = np.arange(5) # np.logical_or(x < 1, x > 3) # np.logical_xor(True, False) # np.logical_xor([True, True, False, False], [True, False, True, False]) x = np.arange(5) # np.logical_xor(x < 1, x > 3) # np.logical_xor(0, np.eye(2)) np.maximum([2, 3, 4], [1, 5, 2]) # np.maximum([np.nan, 0, np.nan], [0, np.nan, np.nan]) # np.maximum(np.Inf, 1) np.minimum([2, 3, 4], [1, 5, 2]) # np.minimum([np.nan, 0, np.nan],[0, np.nan, np.nan]) # np.minimum(-np.Inf, 1) np.fmax([2, 3, 4], [1, 5, 2]) np.fmax(np.eye(2), [0.5, 2]) # np.fmax([np.nan, 0, np.nan],[0, np.nan, np.nan]) np.fmin([2, 3, 4], [1, 5, 2]) np.fmin(np.eye(2), [0.5, 2]) # np.fmin([np.nan, 0, np.nan],[0, np.nan, np.nan]) np.modf([0, 3.5]) np.modf(-0.5) np.multiply(2.0, 4.0) x1 = np.arange(9.0).reshape((3, 3)) x2 = np.arange(3.0) np.multiply(x1, x2) np.negative([1., -1.]) np.not_equal([1., 2.], [1., 3.]) np.not_equal([1, 2], [[1, 3], [1, 4]]) x1 = range(6) np.power(x1, 3) x2 = [1.0, 2.0, 3.0, 3.0, 2.0, 1.0] np.power(x1, x2) x2 = np.array([[1, 2, 3, 3, 2, 1], [1, 2, 3, 3, 2, 1]]) np.power(x1, x2) deg = np.arange(12.) * 30. np.radians(deg) out = np.zeros((deg.shape)) ret = np.radians(deg, out) ret is out np.deg2rad(180) np.reciprocal(2.) np.reciprocal([1, 2., 3.33]) np.remainder([4, 7], [2, 3]) np.remainder(np.arange(7), 5) # np.binary_repr(10) np.right_shift(10, 1) # np.binary_repr(5) np.right_shift(10, [1, 2, 3]) a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]) np.rint(a) np.sign([-5., 4.5]) np.sign(0) # np.sign(5-2j) # np.signbit(-1.2) np.signbit(np.array([1, -2.3, 2.1])) np.copysign(1.3, -1) np.copysign([-1, 0, 1], -1.1) np.copysign([-1, 0, 1], np.arange(3) - 1) np.sin(np.pi / 2.) np.sin(np.array((0., 30., 45., 60., 90.)) * np.pi / 180.) x = np.linspace(-np.pi, np.pi, 201) np.sinh(0) # np.sinh(np.pi*1j/2) np.sqrt([1, 4, 9]) np.sqrt([4, -1, -3 + 4J]) np.cbrt([1, 8, 27]) np.square([-1j, 1]) np.subtract(1.0, 4.0) x1 = np.arange(9.0).reshape((3, 3)) x2 = np.arange(3.0) np.subtract(x1, x2) np.tan(np.array([-pi, pi / 2, pi])) np.tanh((0, np.pi * 1j, np.pi * 1j / 2)) x = np.arange(5) np.true_divide(x, 4) x = np.arange(9) y1, y2 = np.frexp(x) y1 * 2**y2 np.ldexp(5, np.arange(4)) x = np.arange(6) np.ldexp(*np.frexp(x))
def MTNE(self): # dictionary D = np.random.rand(self.p, self.m) lambda_ff_list = [] # Author Aprime_list = [] # weight W_list = [] # dense vector F_list = [] # similarity local X_list = [] X_mask_list = [] # all sparse embeddings across all timestamps # F_big=np.zeros((self.q,self.k)) X_big = np.zeros((self.q, self.q)) X_mask_big = np.zeros((self.q, self.q)) S = np.random.rand(self.q, self.q) indexDict_local2global = collections.OrderedDict() indexDict_global2local = dict() globalIndex = 0 for key in self.edgeDict: A = self.edgeDict[key] X = self.initX(A, self.theta) X = X / (np.amax(X) - np.amin(X)) X_list.append(X) X_mask = np.zeros((self.q, self.q)) # number of nodes in the current time n = A.shape[0] Aprime = np.random.rand(n, self.p) Aprime_list.append(Aprime) indexDict = dict() for i in range(n): indexDict[i] = globalIndex + i indexDict_global2local[globalIndex + i] = (key, i) indexDict_local2global[key] = indexDict for i in range(n): i_big = indexDict[i] for j in range(n): j_big = indexDict[j] X_big[i_big, j_big] = X[i, j] X_mask[i_big, j_big] = 1. X_mask_big[i_big, j_big] = 1. X_mask_list.append(X_mask) globalIndex += n W = np.random.rand(n, self.p) W_list.append(W) F = np.random.rand(n, self.m) F_list.append(F) lambda_ff_list.append(random.random()) F_big = self.concatenateMatrixInList(F_list, self.m, 0) loss_t1 = 1000000000.0 print loss_t1 loss_t = self.epsilon + loss_t1 + 1 while abs(loss_t - loss_t1) >= self.epsilon: #% optimize each element in randomized sequence nita = 1. / math.sqrt(self.t) self.t = self.t + 1 loss_t = loss_t1 loss_t1 = 0.0 counter = 0 for key in self.edgeDict: X = X_list[counter] W = W_list[counter] F = F_list[counter] Aprime = Aprime_list[counter] indexDict = indexDict_local2global[key] lambda_ff = lambda_ff_list[counter] X_mask = X_mask_list[counter] P = self.getP(X_mask, F_big, X_big) n = X.shape[0] for i in range(n): # for A z = Aprime[i] - nita * ( np.dot(np.dot(Aprime[i], W.T) - X[i], W) + self.beta * np.dot(np.dot(Aprime[i], D) - F[i], D.T)) update = np.maximum(np.zeros(np.shape(z)), np.abs(z) - nita * self.lamda_pgd) Aprime[i] = np.sign(z) * update # for F lf_part1 = self.beta * F[i] - np.dot(Aprime[i], D) lf_part2 = np.zeros(self.m) i_big_index = indexDict[i] for j in range(self.q): lf_part2 += self.rho * (F[i] - F_big[j]) * S[i_big_index, j] val1 = np.dot(F[i], F_big.T) val2 = val1 - np.ones(self.q) val3 = np.dot(val2, F_big) lf_part3 = 0.01 * val3 F[i] = F[i] - nita * (lf_part1 + lf_part2 + lf_part3) F_big[i_big_index] = F[i] # vec=np.dot(F[i],F_big.T)-np.ones(self.q) # # print vec.shape # lambda_ff=lambda_ff-nita*np.linalg.norm(vec) # for S ls = (S[i_big_index] - P[i_big_index]) - self.epsilon * np.ones( self.q) - self.alpha * S[i_big_index] S[i_big_index] = S[i_big_index] - nita * ls Aprime = self.chechnegtive(Aprime, None, None) LW = np.dot((np.dot(W, Aprime.T) - X), Aprime) + self.lamda * W W = W - nita * LW W = self.chechnegtive(W, None, None) p1 = np.dot(Aprime, D) - F p2 = self.beta * np.dot(Aprime.T, p1) LD = p2 + self.gamma * D D = D - nita * LD W_list[counter] = W F_list[counter] = F Aprime_list[counter] = Aprime lambda_ff_list[counter] = lambda_ff loss_t1_part = self.lossfuction(X, W, Aprime, F, D) loss_t1 += loss_t1_part counter += 1 # loss_last=self.laplacianLoss(simM,F) simMD, simML = self.getLaplacian(S) trval = np.trace(np.dot(np.dot(F_big.T, simML), F_big)) gapval = self.norm(X_mask_big * (S - X_big)) loss_t1 += self.rho * trval + self.eta * gapval if loss_t < loss_t1 and loss_t != 0: break # print loss_t print loss_t1 return [Aprime_list, F_list, S]
cumulative_update = np.zeros_like(net_params) # initialize update values for ui, k_id in enumerate(kids_rank): np.random.seed(noise_seed[k_id]) # reconstruct noise using seed cumulative_update += utility[ui] * sign(k_id) * np.random.randn( net_params.size) gradients = optimizer.get_gradients(cumulative_update / (2 * N_KID * SIGMA)) return net_params + gradients, rewards if __name__ == "__main__": # utility instead reward for update parameters (rank transformation) base = N_KID * 2 # *2 for mirrored sampling rank = np.arange(1, base + 1) util_ = np.maximum(0, numpy.log(base / 2 + 1) - np.log(rank)) utility = util_ / sum(util_) - 1 / base # training net_shapes, net_params = build_net() env = gym.make(CONFIG['game']).unwrapped optimizer = SGD(net_params, LR) pool = mp.Pool(processes=N_CORE) mar = None # moving average reward for g in range(N_GENERATION): t0 = time.time() net_params, kid_rewards = train(net_shapes, net_params, optimizer, utility, pool) # test trained net without noise net_r = get_reward(
def barrier(S0, K, B, tau, r, q, v, M, N): S = pricepaths(S0, tau, r, q, v, M, N) l = np.min(S, 0) > B payoffs = l * np.maximum(S[-1, :] - K, 0) return math.exp(-r * tau) * np.mean(payoffs)