def regression(alpha, matrix, epsilon):
a=.1 #How do we determine a and b?
b=10
size= matrix.shape[1]-1 #don't want to include last column (y's)
theta= cf.randomThetas(a,b,size)
temp= np.copy(theta)
derVector=np.ones(size)
currentRowIndex= 0
grad= 199 #Just to ensure enters while loop
iterations=0
while iterations < 10000: # Need to update iteration value
iterations+=1
theta= np.copy(temp) #When you enter loop update theta to new values Note: this could also be at end of while loop just depends.
currentRow= np.array(matrix[currentRowIndex:currentRowIndex+1,:matrix.shape[1]-1]) #get row from matrix make into array
currentRow= currentRow[0] # Want to make 1d array currently 2d
rowDeviation = cf.deviation(currentRow, theta)
for i in range(size):
derVector[i]=cf.costDeriv(rowDeviation, theta[i])
temp[i]= theta[i] -(float(alpha)/size)*derVector[i]
if currentRowIndex==matrix.shape[0]-1:
courrentRowIndex=0
else:
currentRowIndex+=1
print costFunction(theta, currentRow, matrix, size)
return theta
def __init__(self, input, rng, n_input, n_reduced, n_reconstructed, sparsity_param, beta=0.01, activation=theano.tensor.nnet.sigmoid):
self.input = input
self.sparsity_param = sparsity_param
self.beta = beta
self.reducedLayer = ReducedLayer(
input=input,
rng=rng,
activation=activation,
n_input=n_input,
n_reduced=n_reduced
)
self.reconstructionLayer = ReconstructionLayer(
input=self.reducedLayer.output,
rng=rng,
activation=activation,
n_reduced=n_reduced,
n_reconstructed=n_reconstructed
)
self.params = self.reducedLayer.params + self.reconstructionLayer.params
self.reconstruction = self.reconstructionLayer.output
self.cost = Cost.squared_error_loss(self.reducedLayer.input, self.reconstructionLayer.output)
self.kul_leib = self.beta * Cost.kullback_leibler_divergence(self.sparsity_param, self.reducedLayer.output)
def Optimal_Data(self, c_list, R_list, thres_CR):
self.c_list = c_list
self.R_list = R_list
self.thres_CR = thres_CR
res = pd.DataFrame()
print('Generate optimal test plans data for ' + self.name + ' RDT')
cR_list = np.array([(c, R) for c in self.c_list for R in self.R_list])
CR_list = []
#PR_list = []
AP_list = []
RDT_list = []
RG_list = []
RG_exp_list = []
WS_list = []
WS_exp_list = []
WS_failureprob_list = []
cost_list = []
n_optimal_list = []
for i in range(len(cR_list)):
self.c = cR_list[i][0]
self.R = cR_list[i][1]
self.n = Optimal.Optimal(self.name, self.pi).Optimal_Sample_Size(self.c, self.R, self.thres_CR)
n_optimal_list.append(self.n)
CR_list.append(Risk.Risk(self.name, n = self.n, c = self.c, pi = self.pi, R = self.R).Consumer_Risk())
#PR_list.append(Risk.Risk(self.name, n = self.n, c = self.c, pi = self.pi, R = self.R).Producer_Risk())
AP_list.append(Risk.Risk(self.name, n = self.n, c = self.c, pi = self.pi, R = self.R).Acceptance_Prob())
RDT_list.append(Cost.Cost(self.name, n = self.n, c = self.c, pi = self.pi, R = self.R).RDT(self.cost_fix, self.cost_var))
RG_list.append(Cost.Cost(self.name, n = self.n, c = self.c, pi = self.pi, R = self.R).Reliability_Growth(self.cost_reliability_growth))
RG_exp_list.append(RG_list[i] * (1 - AP_list[i]))
WS = Cost.Cost(self.name, n = self.n, c = self.c, pi = self.pi, R = self.R).Warranty(self.sales_volume, self. cost_warranty)
WS_list.append(WS[0])
WS_failureprob_list.append(WS[1])
WS_exp_list.append(WS_list[i] * AP_list[i])
cost_list.append(RDT_list[i] + RG_exp_list[i] + WS_exp_list[i])
res['n'] = n_optimal_list
res['c'] = cR_list[:, 0]
res['R'] = cR_list[:, 1]
res['CR'] = CR_list
#res['PR'] = PR_list
res['AP'] = AP_list
res['RDT_Cost'] = RDT_list
res['Reliabiltiy_Growth_Cost'] = RG_list
res['Reliabiltiy_Growth_Cost_exp'] = RG_exp_list
res['Warranty_Services_Cost'] = WS_list
res['Warranty_Services_Failure_Probability'] = WS_failureprob_list
res['Warranty_Services_Cost_exp'] = WS_exp_list
res['Cost_exp'] = cost_list
return res
def __init__(self,
input,
labels,
n_in=None,
n_out=None,
weights=None,
bias=None):
if n_in is not None and n_out is not None:
weights = np.zeros((n_in, n_out), dtype=theano.config.floatX)
bias = value = np.zeros((n_out, ), dtype=theano.config.floatX)
self.weights = theano.shared(value=weights,
name='weights',
borrow=True)
self.bias = theano.shared(value=bias, name='bias', borrow=True)
self.input = input
self.labels = labels
self.predictedHotOne = T.nnet.softmax(
T.dot(self.input, self.weights) + self.bias)
self.predictions = T.argmax(self.predictedHotOne, axis=1)
self.params = [self.weights, self.bias]
self.cost = Cost.negative_log_likelihood(self.predictedHotOne,
self.labels)
self.missclassified = T.mean(T.neq(self.predictions, self.labels))
def __init__(self, input, labels, n_in=None, n_out=None, weights=None, bias=None):
if n_in is not None and n_out is not None:
weights = np.zeros(
(n_in, n_out),
dtype=theano.config.floatX
)
bias = value=np.zeros(
(n_out,),
dtype=theano.config.floatX
)
self.weights = theano.shared(
value=weights,
name='weights',
borrow=True
)
self.bias = theano.shared(
value=bias,
name='bias',
borrow=True
)
self.input = input
self.labels = labels
self.predictedHotOne = T.nnet.softmax(T.dot(self.input, self.weights) + self.bias)
self.predictions = T.argmax(self.predictedHotOne, axis=1)
self.params = [self.weights, self.bias]
self.cost = Cost.negative_log_likelihood(self.predictedHotOne, self.labels)
self.missclassified = T.mean(T.neq(self.predictions, self.labels))
def evaluate(self, solution):
y = solution.variables
solution.objectives[:] = [
-Res.Res(y, self.d, self.hStar),
Cost.Cost(y, self.d)
]
solution.constraints[:] = Constraint.Constraint(y, self.d, self.hStar)
def fitness(self, x):
from epanettools import epanet2 as et
from epanettools.epanettools import EPANetSimulation, Node, Link, Network, Nodes, \
Links, Patterns, Pattern, Controls, Control # import all elements needed
d = EPANetSimulation('/home/varsha/Documents/Project.inp')
f1 = Cost.Cost(x)
f2 = PRI.PRI(x, d)
return [f1, f2]
def regression (alpha, epsilon, gamma, secondsToRun, data, ridge): if not ridge: gamma = 0 size = data[0].size - 1 thetas = Cost.randomThetas(0,0, size) ## make a random list of thetas cur = 0 timeout = time.time() + secondsToRun itera = 0 previousCost = 0 while True: va = np.asarray(data[cur]) v = va[0] thetaT = np.zeros(size) dev = Cost.deviation(v, thetas) cost = Cost.costFunction(thetas, data, gamma) if abs(cost - previousCost) < epsilon or timeout < time.time(): break for i in range(size): thetaT[i] = (1 - alpha * gamma) * thetas[i] - alpha * Cost.costDeriv(dev, v[i]) thetas = thetaT if cur < data.shape[0] - 1: # I don't think this is the number you want. You want the number of rows right? cur += 1 else: cur = 0 itera += 1 ##print costFunction(thetas, data[cur], ) ##print cur ##plt.plot(range(len(lst)), lst,'ro') ##plt.axis([0, len(lst), 0, 40]) ##plt.show() ##plot the size of gradient temp = cost previousCost = cost return thetas
# coding=utf-8
import requests
import json
import Cost
import Hashgain
amount = int(raw_input('Please input the amount of machine:'))
x = Cost.initialize(amount)
y = float(Hashgain.daily_profit(amount))
days = float(x[1])/(y - float(x[0]))
print "Your net profit per day is %.2f" % (y - float(x[0]))
print "Your gross profit is %.2f " % y
print "The first profit will be got after %.1f days" % days
def evaluate(self, solution):
y = solution.variables
solution.objectives[:] = [PRI.PRI(y, self.d), Cost.Cost(y, self.d)]
solution.constraints[:] = Constraint.Constraint(y, self.d)
def cost(self, groundTruth):
return Cost.negative_log_likelihood(self.predictedHotOne, groundTruth)
def buildCostMap(self,testMap):
cost=Cost()
costMap=cost.buildCostMap(testMap)
return costMap
def main(): a = np.ones(10) print cf.deviation(a, a) print cf.gradient(10, np.array([1,2,3]))
import numpy
import Cost, GradientDescent
m = 10000
s = 0
W_perfect = numpy.matrix([2, 1])
b_perfect = float(1.5)
X1_input = numpy.matrix(numpy.random.uniform(-100, 100, (m, 1)))
X2_input = numpy.array(X1_input) * numpy.array(X1_input)
X_input = numpy.append(X1_input, X2_input, axis=1)
y_input = numpy.matrix(
numpy.random.normal((X_input @ W_perfect.T) + b_perfect, s))
cost = Cost.MSE(X_input, y_input)
[W_gd, b_gd, nIter] = GradientDescent.Solve(cost,
learning_rate=1e-1,
max_iterations=1e8,
epsilon=1e-16,
debug_step=10000)
[W_as, b_as] = cost.AnalyticSolve()
print('**********************************************')
print('Input parameters:', W_perfect, b_perfect)
print('Gradient descent:', W_gd, b_gd, '(' + str(nIter) + ')')
print('Analytical :', W_as, b_as)
print('**********************************************')
data = ''
for i in range(X_input.shape[0]):
def buildCostMap(self, testMap):
cost = Cost()
costMap = cost.buildCostMap(testMap)
return costMap
# coding=utf-8
import requests
import json
import Cost
import Hashgain
amount = int(raw_input('Please input the amount of machine:'))
x = Cost.initialize(amount)
y = float(Hashgain.daily_profit(amount))
days = float(x[1]) / (y - float(x[0]))
print "Your net profit per day is %.2f" % (y - float(x[0]))
print "Your gross profit is %.2f " % y
print "The first profit will be got after %.1f days" % days
import sys
import matplotlib.pyplot as plt
import Cost
imgL_path = "data/left.png"
imgR_path = "data/right.png"
inputL_img = imread(imgL_path).astype(np.float32)
inputR_img = imread(imgR_path).astype(np.float32)
D = 192
imgL = torch.FloatTensor(inputL_img).cuda()
imgR = torch.FloatTensor(inputR_img).cuda()
imgL = torch.mean(imgL, 2, keepdim=True)
imgR = torch.mean(imgR, 2, keepdim=True)
cost = torch.zeros_like(imgL)
cost = torch.unsqueeze(cost, 2)
cost = cost.repeat(1, 1, D, 1)
print(cost.shape)
torch.cuda.synchronize()
start_time = time.time()
Cost.Intrinsic_Cost(imgL, imgR, cost, 7)
torch.cuda.synchronize()
deltatime = time.time() - start_time
print("SAD Time: " + str(deltatime))
cost = torch.squeeze(cost, 3)
depth = torch.argmin(cost, 2)
depth = depth.cpu().numpy()
plt.imsave("data/depth.png", depth, cmap='plasma', vmin=0, vmax=D)
