def _exponential_euler(self, __x__, dt, *args, **kwargs):
"""
Exponential Euler evaluation method.
**Notes**
See ``evaluate`` method for parameters.
Only available for equation of the form dy/dt = A + B*y
"""
A = float(self.__A__(*args, **kwargs))
B = float(self.__B__(*args, **kwargs))
AB = A
AB /= B
E = np.exp(-B*dt)
if self._out is not None:
np.mul(__x__,E,self._out)
__x__ = self._out
elif self._in_out is not None:
__x__ *= E
else:
__x__ = __x__*E
__x__ += AB
AB *= E
__x__ -= AB
return __x__
def generate_mosaic(path, w, h):
im = Image.open(path)
im.thumbnail((w, h), Image.ANTIALIAS)
pixel_data = im.load()
mosaic = Image.new("RGB", tuple(mul(FRAGMENT_SIZE, (w, h))))
for x, y in cartesian(im.size):
sys.stdout.write('.')
sys.stdout.flush()
color = pixel_data[x, y]
_, image = closest_color(color, colors)
mosaic.paste(image, tuple(mul(FRAGMENT_SIZE, (x, y))))
return mosaic
def getGramMatrix(self, A, B, K2=None, w=None):
Q = asmatrix(diagflat(1.0 / self.bw2))
AQ = A * Q
K = mul(AQ, A).sum(1) + mul(B * Q, B).sum(1).T
K -= 2.0 * AQ * B.T
if K2 is not None:
K = w * K + (1 - w) * K2
K = ev('exp(-0.5 * K)')
return asmatrix(K)
def conjugateGradient(A, b, x, max_iteration=100, epsilon=10**(-10), w=1):
r = b - mul(A, x)
p = r
iterations = [x]
for k in range(max_iteration):
A_p = mul(A, p)
alpha = iner(r, r) / iner(p, A_p)
iterations.append(iterations[k] + alpha * p)
new_r = r - alpha * A_p
if LA.norm(new_r) < epsilon:
break
beta = iner(new_r, new_r) / iner(r, r)
p = new_r + beta * p
r = new_r
return iterations
def GPRfit(xs, k1, k2, sig):
Ky = sqexp(x, None, k1, k2**0.5)[0] + (sig**2) * np.identity(n)
Ks = sqexp(xs, x, k1, k2**0.5)
Kss = sqexp(xs, None, k1, k2**0.5)[0]
L = cholesky(Ky)
al = solve(T(L), solve(L, y))
fmst = mul(Ks, al)
varfmst = np.empty([n, 1])
for i in range(np.size(xs)):
v = solve(L, T(Ks[:, i]))
varfmst[i] = Kss[i, i] - mul(T(v), v) + sig**2
lmlopt = -0.5 * mul(T(y), al) - np.trace(
np.log(L)) - 0.5 * n * np.log(2 * np.pi)
#return fmst, varfmst[::-1], lmlopt
return fmst, varfmst, lmlopt
def weightedLS(A,Y,w):
At = A.transpose()
w = np.diag(w)
At_w_A = reduce(mul, [At, w, A])
x_weighted = reduce(mul, [inv(At_w_A), At, w, Y])
r = mul(A, x_weighted) - Y
return(x_weighted)
def computeWeighting(self, Q, PHI_S):
self.numSamples, self.numFeatures = PHI_S.shape
self.Q = Q
self.PHI_S = PHI_S
self.PHI_HAT = PHI_S.mean(0)
# initial params
theta = asmatrix(zeros((self.numFeatures, 1)))
eta = max(1.0, std(Q) * 0.1)
bestDiv = Inf
lastDiv = Inf
withoutImprovement = 0
returnWeighting = ones((self.numSamples, 1)) / self.numSamples
for i in range(40):
theta, eta = self._optimizeDualFunction(theta, eta)
weighting = self._computeWeightingFromThetaAndEta(theta, eta)
divKL = self._getKLDivergence(weighting)
if divKL > 3 or isnan(divKL):
print('diVKL warning')
stateFeatureDifference = self.PHI_HAT - mul(PHI_S, weighting).sum(0)
featureError = abs(stateFeatureDifference).max()
print('Feature Error: {:f}, KL: {:f}'.format(featureError, divKL))
if not isinf(bestDiv) and i >= 10 and featureError >= bestDiv:
withoutImprovement = withoutImprovement + 1
if withoutImprovement >= 3:
print('No improvement within the last 3 iterations.')
break
if abs(divKL - self.epsilonAction) < 0.05 \
and featureError < 0.01 \
and featureError < bestDiv:
print('Accepted solution.')
withoutImprovement = 0
returnWeighting = weighting
bestDiv = featureError
if abs(divKL - self.epsilonAction) < 0.05 \
and featureError < 0.001:
print('Found sufficient solution.')
break
if (abs(stateFeatureDifference) - lastDiv).max() > -0.000001:
print('Solution unchanged or degrading, restart from new point')
theta = random.random(theta.shape) * 2.0 - 1.0
lastDiv = Inf
else:
lastDiv = featureError
return returnWeighting
def gaussSeidel(A, b, x, max_iteration=100, w=1, epsilon=10**(-10)):
iterations = [x]
D = np.diag(np.diag(A))
L = np.tril(A, -1)
l_and_d = inv(L + D)
for k in range(max_iteration):
x = iterations[k]
x = x + mul(l_and_d, b - mul(A, x))
iterations.append(x)
r = mul(A, x) - b
norm = LA.norm(r)
if norm <= epsilon:
break
return iterations
def task_2b(l=1,eps=0.001):
x_1 = np.arange(0.0, 5.1, 0.1)
x_1 = x_1.reshape((51, 1))
x_i=x_1
n = x_i.shape[0]
w= np.ones(n)
A = np.identity(n)
G = G_matrix(n)
for i in range(0, 10):
print("w: {0}\n".format(w))
Y = y_func(x_i)
print("Y: {0}\n".format(Y))
x_i=weightedLS(A,Y,w)
print("x_i: {0}\n".format(x_i))
G_x_i=mul(G,x_i)
print("G_x_i: {0}\n".format(G_x_i))
for j in range(0,n-1):
w[j]=1/(math.fabs(G_x_i[j])+eps)
# plt.plot(x_1, y_func(x), 'r')
# plt.plot(x_1.reshape(x_1.shape[0],1, f(x_1), 'b'))
# plt.plot(x_i.reshape(x_i.shape[0],1, f(x_i), 'r'))
# plt.title("task 3b")
# plt.show()
# plt.plot(x_i, x_i, 'b')
# plt.plot(x_1, y_func(x_1), 'r')
plt.plot(x_1, f(x_1), 'b')
plt.plot(x_1, x_i, 'r')
plt.title("task 2b")
plt.show()
def sampleActions(self, S):
if not self.trained:
return self._getRandomActions(S.shape[0])
actionDim = self.alpha.shape[1]
kVec = self.GPPriorVariance * self.kernel.getGramMatrix(self.Ssub, S).T
meanGP = dot(kVec, self.alpha)
temp = solve(self.cholKy.T, kVec.T)
temp = square(temp.T)
sigmaGP = temp.sum(1)
kernelSelf = self.GPPriorVariance * self.kernel.getGramDiag(S)
sigmaGP = kernelSelf.squeeze() - sigmaGP.squeeze()
sigmaGP = asarray(sigmaGP).squeeze()
if sigmaGP.shape == (): # single number
sigmaGP = matrix([sigmaGP])
sigmaGP[sigmaGP < 0] = 0
sigmaGP = tile(sqrt(sigmaGP)[:, newaxis], (1, actionDim))
if self.UseGPBug:
sigmaGP += sqrt(self.GPRegularizer)
else:
sigmaGP = sqrt(square(sigmaGP) + self.GPRegularizer)
sigmaGP[sigmaGP < self.GPMinVariance] = self.GPMinVariance
N = random.normal(0.0, 1.0, (S.shape[0], actionDim))
A = mul(N, sigmaGP) + meanGP
return A
def svd():
u, s, vt = np.linalg.svd(A, full_matrices=False)
s = np.diag(s)
x_svd = reduce(mul, [vt.transpose(), inv(s), u.transpose(), b])
r = mul(A,x_svd) - b
print("least squares via SVD\n",x_svd)
print("r:\n", r)
def _dualFunction(self, params):
theta = asmatrix(params[0:self.numFeatures]).T
eta = params[-1]
epsilon = self.epsilonAction
V = self.PHI_S * theta
VHat = self.PHI_HAT * theta
advantage = self.Q - V
maxAdvantage = advantage.max()
QNorm = self.Q - maxAdvantage
advantage = (QNorm - V) / eta
g = 0
gD = zeros((self.numFeatures + 1,))
if advantage.max() > 500:
g = 1e30 - eta
gD[-2] = -1
return g, gD
expAdvantage = ev('exp(advantage)')
sumExpAdvantage = expAdvantage.sum()
realmin = finfo(double).tiny
if sumExpAdvantage < realmin:
sumExpAdvantage = realmin
gLogPart = (1.0 / self.numSamples) * sumExpAdvantage
g += eta * log(gLogPart) + VHat + maxAdvantage
g += eta * epsilon + self.alphaL2ThetaPunishment * (theta.T * theta)
# gradient
if (eta * sumExpAdvantage) == 0:
gDEta = 1e100
else:
gDEta = epsilon + log(gLogPart) - \
mul(expAdvantage, QNorm - V).sum() / (eta * sumExpAdvantage)
gD[-1] = gDEta
gDTheta = self.PHI_HAT + mul(-self.PHI_S, expAdvantage).sum(0) / \
sumExpAdvantage + 2 * self.alphaL2ThetaPunishment * theta.T
gD[0:self.numFeatures] = gDTheta
return g, 0.5 * gD
def armijo(max_iter, x, f, gradient, direction, alpha=1, b=0.5, c=10**-5):
while max_iter > 0:
objective = f(x + alpha * direction)
limit = f(x) + c * alpha * mul(gradient.transpose(), direction)
if objective <= limit:
break
alpha = alpha * b
max_iter = max_iter - 1
return alpha
def findNearest(y, y_train, w, test):
_min = 1e8
pre_label = 0
y_pre = mul(w.T, test) # continous value
for i in range(len(y)):
if abs(y_pre - y[i]) < _min:
_min = abs(y_pre - y[i])
pre_label = y_train[i]
return pre_label
def weighted_least_squares():
At = A.transpose()
w = np.array([1000,1, 1, 1])
w = np.diag(w)
At_w_A = reduce(mul, [At, w, A])
x_weighted = reduce(mul, [inv(At_w_A), At, w, b])
r = mul(A, x_weighted) - b
print("X weighted least squares\n", x_weighted)
print(r)
print(r[0][0])
print(abs(r[0][0]) < 1/1000 )
def ass_a():
x = np.zeros(10)
iterations = [x]
D = np.diag(np.diag(L))
inv_D = inv(D)
norm_list = []
for k in range(100):
x = x + mul(inv_D, b - mul(L, x))
iterations.append(x)
r = mul(L, x) - b
norm = LA.norm(r)
norm_list.append(norm)
if norm <= 10**-5:
break
print("iteration number of 4a:", k)
plot.semilogy(norm_list, label='jacobi')
plot.title("question 4a")
plot.show()
def rcost(y, u):
"""
Running cost (a.k.a. utility, reward, instantaneous cost etc.)
See class documentation
"""
chi = np.concatenate([y, u])
r = 0
R1 = np.diag([1, 100, 1, 0, 0, 0, 0]) #self.rcost_pars[0] ->R1
r = np.mul(chi, R1, chi)
return r
def newton(max_iter, x_k, alpha, epsilon, f, df):
output = []
first_alpha = alpha
while max_iter > 0:
output = output + [x_k]
f_theta = f(x_k)
J = df(x_k)
Jt_J = mul(J.transpose(), J)
gradient = mul(J.transpose(), f_theta - data)
d_LM = mul(inv(Jt_J), -gradient)
alpha = armijo(20, x_k, f, gradient, d_LM, first_alpha)
next_x = np.array(x_k) + alpha * d_LM
# if stop(x_k, next_x, epsilon):
# break
x_k = next_x
max_iter = max_iter - 1
output = output + [x_k]
return output
def learnLSTD(self, stateActionFeatures, nextStateActionFeatures, reward):
phi = asmatrix(stateActionFeatures)
phi_ = asmatrix(nextStateActionFeatures)
A_ = phi.T * (phi - self.discountFactor * phi_)
b_ = mul(phi, reward).sum(0).T
n = phi.shape[1]
C = phi * inv(phi.T * phi + self.lstdRegularizationFactor * eye(n))
X = C * (A_ + self.lstdRegularizationFactor * eye(n))
y = C * b_
return solve(X.T * X + self.lstdProjectionRegularizationFactor * eye(n),
X.T * y)
def ass_b():
m1 = L[:3, :3]
m2 = L[3:, 3:]
inv_m1 = inv(m1)
inv_m2 = inv(m2)
inv_m = np.zeros(100).reshape(10, 10)
inv_m[:3, :3] = inv_m1
inv_m[3:, 3:] = inv_m2
x = np.zeros(10)
iterations = [x]
for k in range(100):
x = x + mul(0.7 * inv_m, b - mul(L, x))
iterations.append(x)
r = mul(L, x) - b
norm = LA.norm(r)
if norm <= 10**-5:
break
print("iteration number of 4b:", k)
x_asix = list(map(lambda u: LA.norm(mul(L, u) - b), iterations))
plot.semilogy(x_asix, label='jacobi')
plot.title("question 4b")
plot.show()
def computeGuellrichDomain2D(DIMS, REFS, hx, dhdx):
# Get data from DIMS and REFS
ZH = DIMS[2]
NX = DIMS[3] + 1
NZ = DIMS[4]
# input REFS = [x, z, HFM, whf, CPM, wcp]
x = REFS[0]
z = REFS[1]
# Compute the flat XZ mesh
HTZL, dummy = np.meshgrid(hx, z)
XL, ZL = np.meshgrid(x, z)
# High Order Improved Guellrich coordinate 3 parameter function
xi = 1.0 / ZH * ZL
ang = 0.5 * mt.pi * xi
AR = 1.0E-3
p = 20
q = 5
expdec = np.exp(-p / q * xi)
cosvar = np.power(np.cos(ang), p)
cosvard = np.power(np.cos(ang), p - 1)
fxi1 = mul(expdec, cosvar)
fxi2 = AR * mul(xi, (1.0 - xi))
fxi = np.add(fxi1, fxi2)
dfdxi1 = -p / q * mul(expdec, cosvar)
dfdxi2 = -(0.5 * p) * mt.pi * mul(mul(expdec, np.sin(ang)), cosvard)
dfdxi3 = -AR * (1.0 - 2.0 * xi)
dfdxi = np.add(np.add(dfdxi1, dfdxi2), dfdxi3)
dzdh = fxi
dxidz = ZH + mul(HTZL, np.add(dfdxi, -fxi))
sigma = ZH * np.power(dxidz, -1.0)
# Make the global array of terrain height and slope features
ZTL = np.zeros((NZ, NX))
DZT = np.zeros((NZ, NX))
for rr in range(NZ):
ZTL[rr, :] = np.add(mul(dzdh[rr, :], hx), ZL[rr, :])
DZT[rr, :] = mul(dzdh[rr, :], dhdx)
return XL, ZTL, DZT, sigma
def chebpolym(NM, xi):
# Compute Chebyshev pols (first kind) into a matrix transformation
# Functions need to be arranged bottom to top!
NX = len(xi)
CTM = np.zeros((NX, NM + 1))
CTM[:, 0] = np.ones(NX)
CTM[:, 1] = xi
# 3 Term recursion
for ii in range(2, NM + 1):
CTM[:,ii] = 2.0 * \
mul(xi, CTM[:,ii-1]) - \
CTM[:,ii-2]
return CTM
def train(self, S, A, w, Ssub):
self.Ssub = Ssub
# kernel matrix on subset of samples
K = self.GPPriorVariance * \
self.kernel.getGramMatrix(self.Ssub, self.Ssub)
w /= w.max()
GPRegularizerEffective = self.GPRegularizer
counter = 1
while True:
Ky = K + eye(K.shape[0]) * GPRegularizerEffective
try:
self.cholKy = chol(Ky)
break
except LinAlgError:
GPRegularizerEffective *= 2
counter += 1
assert counter < 100, 'SparseGPPolicy: chol failed'
kernelVectors = self.GPPriorVariance * \
self.kernel.getGramMatrix(self.Ssub, S).T
cholKyInvReg = 0
while True:
try:
cholKyInv = pinv(self.cholKy + cholKyInvReg * eye(self.cholKy.shape[0]))
cholKyInvT = pinv(self.cholKy.T + cholKyInvReg * eye(self.cholKy.shape[0]))
break
except LinAlgError:
if cholKyInvReg == 0:
cholKyInvReg = 1e-10
else:
cholKyInvReg *= 2
featureVectors = dot(dot(kernelVectors, cholKyInv), cholKyInvT)
featureVectorsW = mul(featureVectors, w)
X = dot(featureVectorsW.T, featureVectors)
X += eye(featureVectors.shape[1]) * self.SparseGPInducingOutputRegularization
y = dot(solve(X, featureVectorsW.T), A)
self.alpha = solve(self.cholKy, solve(self.cholKy.T, y))
self.trained = True
def exact_Newton(f, jacobian, gardient, x_0, eps=10**-3, max_iterations=100):
x_k = np.clip(x_0, -1, 1)
output = []
for i in range(0, max_iterations):
d_n = -mul(np.linalg.inv(jacobian(x_k)), gardient(x_k))
d_n = np.reshape(d_n, d_n.size)
a = armijo(x_k, -d_n, f, gardient)
# a=1
next_x = x_k + a * d_n
next_x = np.clip(next_x, -1, 1)
if (np.linalg.norm(x_k) != 0):
if np.linalg.norm(next_x - x_k) / np.linalg.norm(x_k) < eps:
output = output + [next_x]
return output
output = output + [next_x]
x_k = next_x
return output
def parseExpr(expr):
if expr.data == "add":
return add(parseExpr(expr.children[0]), parseExpr(expr.children[1]))
elif expr.data == "sub":
return sub(parseExpr(expr.children[0]), parseExpr(expr.children[1]))
elif expr.data == "mul":
return mul(parseExpr(expr.children[0]), parseExpr(expr.children[1]))
elif expr.data == "div":
return div(parseExpr(expr.children[0]), parseExpr(expr.children[1]))
elif expr.data == "neg":
return neg(parseExpr(expr.children[0]))
elif expr.data == "word":
word = expr.children[0].value.lower()
if word in w2idx.keys():
return mat[w2idx[word]]
else:
return np.zeros(100)
def ConjugateGradient2(A,
b,
naught=None,
ShowProgress=True,
tol=1e-8,
lo=0,
hi=0,
max_iter=20000,
dt=float64):
#
# preamble
#
if naught is None:
naught = [uniform(lo, hi) for w in range(len(b))]
# if isinstance(A, Matrix): # only for compatability with the above, otherwise can be omitted
# A = arr(A.body, dtype=dt)
A = A.astype(dt)
x = arr([naught], dtype=dt).T # convert list into numpy column vector
b = arr([b], dtype=dt).T
r = b - mul(A, x) # resideual
v = arr([j for j in r], dtype=dt)
Measure = norm((mul(A, x) - b).T[0], ord=inf)
modr = mul(r.T, r)[0][0]
#
# iterate
#
k = 0
while (k < max_iter and Measure > tol * max(x.max(), x.min())):
Av = mul(A, v)
modv = mul(v.T, Av)[0][
0] # modulus (aka. norm) of v w.r.t. the inner product (x,y):=x^TAy (this is an inner prod when A is symmetric)
alpha = float(modr) / modv
x += alpha * v
r -= alpha * Av
mod_old_r = modr
modr = mul(r.T, r)[0][0] # ||b-alphaAv||^2, not ||residual||^2
alpha = float(modr) / mod_old_r # ||new.r||^2 / ||old.r||^2
v = r + alpha * v
k += 1
Measure = norm((mul(A, x) - b).T[0], ord=inf)
if ShowProgress:
print('k=' + str(k) + '; ' + str(Measure))
#
# postamble
#
return {'soln': x, 'times': k}
def Intersect(self, i):
# Transform ray into object space
o = PointMul(self.inv_xform, i.ray.o)
dir = VecMul(self.inv_xform, i.ray.dir)
dir_n = Normalize(dir)
# Assume sphere is centered at origin with radius 1.0 in object space
b = 2.0 * dot(dir_n, o)
c = dot(o, o) - 1
# Use quadratic formula to solve for t
delta = b * b - 4 * c
if (delta < -EPSILON): # no intersection if k is negative
return (False)
t = 0
if (delta < EPSILON): # intersects only once (on tangent)
t = -b / 2.0
else:
sqrt_delta = sqrt(delta)
t0 = (-b - sqrt_delta) / 2.0
t1 = (-b + sqrt_delta) / 2.0
if (t0 > EPSILON and t1 > EPSILON):
t = min(t0, t1) # first intersection along ray
elif (t0 > EPSILON):
t = t0 # t1 is behind ray
elif (t1 > EPSILON):
t = t1 # t0 is behind ray
else:
return (False) # ray intersection are both behind ray
t_dir = mul(t, dir_n) # scaled dir vec in global space
t_dir_glob = VecMul(self.xform, t_dir) # in global space
i.dist = LA.norm(t_dir_glob)
i.p = add(i.ray.o, t_dir_glob)
p_obj = add(o, t_dir)
i.n = VecMul(self.xform, p_obj)
i.uv = (
(atan2(p_obj[2], p_obj[0]) + pi) / (2.0 * pi), # longitude angle
acos(p_obj[1]) / pi) # latitude angle
return True
def gramSchmidtQR(a):
m, n = a.shape
# initiation
r = np.zeros(shape=(n, n))
q = np.zeros(shape=(m, n))
a1 = a[:, 0]
r[0][0] = LA.norm(a1, ord=2)
q[:, 0] = a1 / r[0][0]
for i in range(1, n):
ai = a[:, i]
q[:, i] = ai
for j in range(0, i):
qj = q[:, j]
r[j][i] = mul(qj.transpose(), ai)
q[:, i] = q[:, i] - r[j][i] * qj
r[i][i] = LA.norm(q[:, i], ord=2)
q[:, i] = q[:, i] / r[i][i]
return q, r
def generate_2QB_Cliffords(_index):
seq_QB1 = []
seq_QB2 = []
sequence_rb.add_twoQ_clifford(_index, seq_QB1, seq_QB2)
m2QBClifford = np.identity(4, dtype=complex)
for i in range(len(seq_QB1)):
_mGate = np.matrix([1])
if (seq_QB1[i] == gates.CZ
or seq_QB2[i] == gates.CZ): # two qubit gates
_mGate = np.kron(dict_m2QBGate['CZ'], _mGate)
else: # 1QB gates
for g in [seq_QB2[i], seq_QB1[i]]:
if (g == gates.I):
_mGate = np.kron(dict_m1QBGate['I'], _mGate)
elif (g == gates.Xp):
_mGate = np.kron(dict_m1QBGate['Xp'], _mGate)
elif (g == gates.Xm):
_mGate = np.kron(dict_m1QBGate['Xm'], _mGate)
elif (g == gates.X2p):
_mGate = np.kron(dict_m1QBGate['X2p'], _mGate)
elif (g == gates.X2m):
_mGate = np.kron(dict_m1QBGate['X2m'], _mGate)
elif (g == gates.Yp):
_mGate = np.kron(dict_m1QBGate['Yp'], _mGate)
elif (g == gates.Ym):
_mGate = np.kron(dict_m1QBGate['Ym'], _mGate)
elif (g == gates.Y2p):
_mGate = np.kron(dict_m1QBGate['Y2p'], _mGate)
elif (g == gates.Y2m):
_mGate = np.kron(dict_m1QBGate['Y2m'], _mGate)
elif (g == gates.Zp):
_mGate = np.kron(dict_m1QBGate['Zp'], _mGate)
elif (g == gates.Zm):
_mGate = np.kron(dict_m1QBGate['Zm'], _mGate)
elif (g == gates.Z2p):
_mGate = np.kron(dict_m1QBGate['Z2p'], _mGate)
elif (g == gates.Z2m):
_mGate = np.kron(dict_m1QBGate['Z2m'], _mGate)
m2QBClifford = mul(_mGate, m2QBClifford)
return (m2QBClifford)
def desent(max_iter, x_k, alpha, epsilon, f, df):
output = [x_k]
while max_iter > 0:
f_theta = f(x_k)
J = df(x_k)
curr_gradient = mul(J.transpose(), f_theta - data)
gradient_norm = LA.norm(curr_gradient)
normal_gradient = curr_gradient / gradient_norm
curr_alpha = armijo(30, x_k, f, normal_gradient, -normal_gradient, alpha)
D = curr_alpha * normal_gradient
next_x = x_k + D
# if stop(x_k, next_x, epsilon):
# output = output + [x_k]
# break
x_k = next_x
output = output + [x_k]
max_iter = max_iter - 1
return output
def Shade(self, i):
i.color = self.texture.Sample(i.uv)
n_norm = Normalize(i.n)
e_norm = Normalize(i.ray.dir)
e_dot_n = dot(e_norm, n_norm)
r = Normalize(add(e_norm, mul(-2.0 * e_dot_n, n_norm)))
diffuse = (0.0, 0.0, 0.0)
specular = (0.0, 0.0, 0.0)
for light in i.scene.lights:
light_info = light.GetLightSampleInfo(i)
light_dist = LA.norm(light_info.dir)
l_norm = mul(light_info.dir, 1.0 / light_dist)
# Trace shadows
if (i.next != None):
i.next.ray.Set(i.p, l_norm, True)
if (i.next.Trace(False, True)):
if (i.next.dist < light_dist):
continue
l_dot_n = dot(l_norm, n_norm)
if (l_dot_n > 0.0):
diffuse = add(diffuse, mul(l_dot_n, light_info.emission))
spec = l_dot_n * pow(dot(r, l_norm), self.spec_exp)
specular = add(specular, mul(spec, light_info.emission))
i.color = add(mul(i.color, diffuse), mul(self.ks, specular))
i.opacity = [1, 1, 1]
# Trace reflection
if (i.next != None):
if (GreaterThan3(self.kr, .01)):
i.next.ray.Set(i.p, r, True)
if (i.next.Trace(True)):
i.color = add(i.color, mul(i.next.color, self.kr))
def add_graph_line_first(fun, A, b, x, w, label, max_iterations=100):
ans = fun(A, b, x, max_iterations, w=w)
x_asix = list(map(lambda u: LA.norm(mul(A, u) - b), ans))
plot.semilogy(x_asix, label=label)
def iner(a, b):
return mul(a.transpose(), b)
import numpy as np
import pandas as pd
from pandas import read_csv
from numpy import transpose as tp
from numpy import matmul as mul
x = read_csv('./NN_Datasets/face_x.txt', header=None, delimiter=' ').values
y = read_csv('./NN_Datasets/face_y.txt', header=None, delimiter=' ').values
w = tp(2 * np.random.rand(x.shape[1], 1) - 1)
b = 2 * np.random.rand(1, 1) - 1
f = tp(mul(w, tp(x))) - b
err = np.sum(y * f <= 0)
print(err)
def __mask2mat(self, mask):
k, h, w = mask.shape
v = mask.reshape(k, h * w)
mat = np.mul(v.T, v)
return mat
def muls(dst, one, two): with stats['muls']: np.mul(one.np, two, out=dst.np)
def mul(dst, one, two): with stats['mul']: np.mul(one.np, two.np, out=dst.np)
def vifSelect(m, xs, ys):
w = 0.5
deltaw = .05
vcxs = np.matrix(xs).T
center(vcxs)
ys = np.array(ys)
mys = np.matrix(ys)
subsample = sample(range(len(xs[0])), m)
f = 0
rmse = np.std(ys)
residuals = np.matrix([y - ys.mean() for y in ys])
model = np.matrix([1] * m).T
results = np.matrix([1] * len(xs[0])).T
whichVars = []
for j in range(len(xs)):
alpha = w / (1 + j - f)
gammahat = residuals.dot(vcxs[:, j]) / norm(vcxs[:, j])
xsub = []
for i in subsample:
xsub.append(vcxs[i, j])
xsub = np.matrix(xsub).T
matrixOfFun = mul(
mul(mul(xsub.T, model), np.linalg.inv(mul(model.T, model))),
mul(model.T, xsub))
rsquared = matrixOfFun[0, 0] / (norm(xsub)**2)
t = gammahat / (rmse * np.sqrt(1 - rsquared))
cdfval = 2 * normal.cdf(-abs(t))
if cdfval < alpha:
model = np.hstack((model, xsub))
results = np.hstack((results, vcxs[:, j]))
whichVars.append(j)
residuals = mys - mul(
mul(mul(results, np.linalg.inv(mul(results.T, results))),
results.T), ys)
rmse = norm(residuals) / np.sqrt(len(xs[0]) - 1 - model.shape[1])
w = w + deltaw
f = j
else:
w = (w - alpha) / (1 - alpha)
coeffs = mul(mul(np.linalg.inv(mul(results.T, results)), results.T), ys)
return coeffs, whichVars
def qr():
Q, R = np.linalg.qr(A)
x_qr = reduce(mul, [inv(R), Q.transpose(), b])
r = mul(A,x_qr) - b
print("least squares via QR factorization:\n",x_qr)
print("r:\n", r)
def F_gradient(teta, f, df):
J = df(teta)
return mul(J.transpose, f(teta) - data)
