def response_model(self,
k=5 * np.pi,
n=10,
angle_increment=128,
peakWidth=28.0 / 180.0 * np.pi,
sidelobeHeight=-24):
self.response_model = ResponseModel(k, n, angle_increment, peakWidth,
sidelobeHeight)
class LinearRegressionModel:
def __init__(self,
k=5 * np.pi,
n=10,
angle_increment=128,
sample_size=100,
stdev=0.0):
self.K = k
self.N = n
self.N_phi = angle_increment
self.SAMPLES = sample_size
self.response_model()
self.Stdev = stdev
self.filename = "data/2018-08-02_16.32/"
def response_model(self,
k=5 * np.pi,
n=10,
angle_increment=128,
peakWidth=28.0 / 180.0 * np.pi,
sidelobeHeight=-24):
self.response_model = ResponseModel(k, n, angle_increment, peakWidth,
sidelobeHeight)
def get_fireflies_positions(self):
dfx = pd.read_csv(self.filename + "xNew.csv", header=None)
return dfx
def get_fireflies_responses(self):
dfr = pd.read_csv(self.filename + "R.csv", header=None)
return dfr
def samplePercentileRange(self, min, max, length):
dif = max - min
rand = np.random.rand(length)
scaled = rand * dif
finished = scaled + min
return finished
def calculateDifs(self, dfx):
dif = dfx.diff(axis=1)
dif[0] = dfx[0]
dif[10] = 1 - dfx[9]
return dif
def linearRegOld(self, dfx):
dif = dfx.diff(axis=1)
dif[10] = 1 - dfx[9]
num = len(dif.columns)
slope = np.empty(num - 2)
intercept = np.empty(num - 2)
r_value = np.empty(num - 2)
p_value = np.empty(num - 2)
std_err = np.empty(num - 2)
for i in range(1, num - 1):
y = dif[i]
x = dif[i + 1]
slope[i - 1], intercept[i - 1], r_value[i - 1], p_value[
i - 1], std_err[i - 1] = stats.linregress(x, y)
return slope, intercept
def linearReg(self, dif):
num = len(dif.columns)
slope = np.empty(num - 1)
intercept = np.empty(num - 1)
r_value = np.empty(num - 1)
p_value = np.empty(num - 1)
std_err = np.empty(num - 1)
for i in range(0, num - 1):
x = dif[i]
y = dif[i + 1]
slope[i], intercept[i], r_value[i], p_value[i], std_err[
i] = stats.linregress(x, y)
return slope, intercept
def linearRegInverse(self, dif):
num = len(dif.columns)
slope = np.empty(num - 1)
intercept = np.empty(num - 1)
r_value = np.empty(num - 1)
p_value = np.empty(num - 1)
std_err = np.empty(num - 1)
for i in range(0, num - 1):
y = dif[i]
x = dif[i + 1]
slope[i], intercept[i], r_value[i], p_value[i], std_err[
i] = stats.linregress(x, y)
return slope, intercept
def generateLastElement(self, last_point, slopes, intercepts):
rslopes = np.flip(slopes, 0)
rintercepts = np.flip(intercepts, 0)
antenna = np.empty(len(rslopes) + 1)
antenna[0] = last_point
for i in range(1, self.N):
if (i == 1):
dif = 1 - antenna[i - 1]
else:
dif = antenna[i - 2] - antenna[i - 1]
antenna[i] = antenna[i - 1] - (
(rslopes[i - 1] * dif) + rintercepts[i - 1])
return np.flip(antenna, 0)
def generateAny(self, separation, index, slopes, intercepts, slopesr,
interceptsr):
differences = np.empty(self.N)
differences[index] = separation
for i in range(index, (self.N - 1)):
differences[i + 1] = (slopes[i] * differences[i]) + intercepts[i]
for i in range(0, index):
j = index - i
differences[j - 1] = (differences[j] *
slopesr[j - 1]) + interceptsr[j - 1]
firefly = np.cumsum(differences)
return firefly
def generateAnyNew(self, separation, index, slopes, intercepts, slopesr,
interceptsr):
differences = np.empty(self.N + 1)
differences[index] = separation
for i in range(index, (self.N)):
differences[i + 1] = (slopes[i] * differences[i]) + intercepts[i]
for i in range(0, index - 1):
j = index - i
differences[j - 1] = (differences[j] *
slopesr[j - 1]) + interceptsr[j - 1]
differencesr = np.flip(differences, 0)
positionsr = 1 - np.cumsum(differencesr)
positions = np.flip(positionsr, 0)[1:]
# print differences
# print differencesr
# print positionsr
# print positions
return positions
def randomMovement(self, x, stdev):
if (np.random.rand(1) > 0.5):
if x + stdev > 1:
movement = (1 - x) * np.random.normal(0, stdev)
else:
movement = np.random.normal(0, stdev)
else:
if x - stdev < 0:
movement = (0 - x) * np.random.normal(0, stdev)
else:
movement = stdev * np.random.normal(0, stdev) * -1.0
return x + movement
def randomMovements(self, x, stdev):
for i in range(0, self.N):
x[i] = self.randomMovement(x[i], stdev)
return x
def generateFromLinRegressLast(self):
dfx = self.get_fireflies_positions()
tenth = np.percentile(dfx, 10.0, axis=0)
ninetieth = np.percentile(dfx, 90.0, axis=0)
slopes, intercepts = self.linearRegOld(dfx)
fireflies = np.array(
[np.empty(self.N) for i in range(0, self.SAMPLES)])
for i in range(0, self.SAMPLES):
index = 9
initials = self.samplePercentileRange(tenth[index],
ninetieth[index], 1)
initials = 0.95
generated = self.generateLastElement(initials, slopes, intercepts)
fireflies[i] = self.randomMovements(generated, self.Stdev)
return fireflies
def generateFromLinRegressAny(self):
dfx = self.get_fireflies_positions()
dif = self.calculateDifs(dfx)
tenth = np.percentile(dif, 05.0, axis=0)
ninetieth = np.percentile(dif, 95.0, axis=0)
slopes, intercepts = self.linearReg(dif)
slopesr, interceptsr = self.linearRegInverse(dif)
fireflies = np.array(
[np.empty(self.N) for i in range(0, self.SAMPLES)])
for i in range(0, self.SAMPLES):
index = np.random.randint(0, 10) + 1
# index = 7
initials = self.samplePercentileRange(tenth[index],
ninetieth[index], 1)
# initials = 0.05
generated = self.generateAnyNew(initials, index, slopes,
intercepts, slopesr, interceptsr)
fireflies[i] = self.randomMovements(generated, self.Stdev)
return fireflies
def analyze(self, fireflies, show=False):
responses = np.empty([self.SAMPLES, self.N_phi])
fitnesses = np.empty(self.SAMPLES)
for index in range(0, self.SAMPLES):
firefly = fireflies[index]
responses[index] = self.response_model.angleSpectrum(firefly)
fitnesses[index] = self.response_model.calculateFitness(
functions.convertDb(responses[index]))
averageResponse = functions.convertDb(np.mean(responses, axis=0))
variance = np.var(responses, axis=0)
meanFitness = np.mean(fitnesses)
if show == True:
for i in range(0, 10):
x = fireflies[:, i]
count, bins = np.histogram(x, bins=50, density=True)
plt.plot(bins[:-1], count)
plt.xlim([0, 1])
plt.title("Positions Generated from Linear Regression")
plt.show()
fig = plt.figure()
plt.plot(averageResponse, label="Mean from model")
# plt.plot(average, label="Theoretical")
plt.plot(self.response_model.getRt(), label="Desired")
plt.legend()
plt.ylim([-65, 5])
plt.show()
plt.plot(variance, label="Experimental")
plt.legend()
plt.show()
print meanFitness
return averageResponse, variance, meanFitness
def samples(self):
# fits = np.empty(30)
# stdev = np.empty(30)
# for i in range (0,30):
# r_, v_, fits[i] = self.analyze(self.generateFromLinRegressAny())
# stdev[i] = self.Stdev
# self.Stdev += 0.01
# plt.plot(stdev, fits, label="From Random Separation")
self.Stdev = 0.0
fits = np.empty(30)
stdev = np.empty(30)
for i in range(0, 30):
r_, v_, fits[i] = self.analyze(self.generateFromLinRegressLast())
stdev[i] = self.Stdev
self.Stdev += 0.01
plt.plot(stdev, fits, label="From Last Separation")
# self.Stdev = 0.0
# fits = np.empty(30)
# stdev = np.empty(30)
# for i in range (0,30):
# fireflies = self.get_fireflies_positions
# r_, v_, fits[i] = self.analyze(self.randomMovements(fireflies, self.tdev))
# stdev[i] = self.Stdev
# self.Stdev += 0.01
# plt.plot(stdev, fits, label="From Firefly")
plt.xlabel('Standard Deviation')
plt.ylabel('Average Fitness')
plt.title("Standard Deviation of Noise vs. Average Fitness")
plt.legend()
plt.show()
class Firefly:
def __init__(self, n=10, nff=100, alpha=1.0/80.0, gamma=10.0, t=100):
self.N = n
self.Nff = nff
self.Alpha = alpha
self.Gamma = gamma
self.T = t
def response_model(self, k=5*np.pi, angle_increment=128, peakWidth=28.0/180.0*np.pi, sidelobeHeight=-24):
self.response_model = ResponseModel(k, angle_increment, peakWidth, sidelobeHeight)
def generate_initials(self):
rand.seed()
self.fireflies = [np.sort(np.random.rand(self.N)) for i in range (0, self.Nff)]
self.responses = [self.response_model.angleSpectrum(self.fireflies[j]) for j in range (0, self.Nff)]
self.response_constraint = self.response_model.getRt()
self.fitnesses = [self.response_model.calculateFitness(functions.convertDb(self.responses[k])) for k in range (0, self.Nff)]
self.average_fitnesses_over_time = [0 for l in range (0, self.T)]
self.average_fitnesses_over_time[0] = np.mean(self.fitnesses)
def calculate_convergence(self, xi=[], xt=[]):
distance = functions.distance(self.N, xi, xt)
xn = (np.exp(-self.Gamma*(distance**2)))* (xt-xi)
return xn
def total_convergence(self, index, fireflies, fitnesses):
fitness = fitnesses[index]
xi = fireflies[index]
for i in range (0, self.Nff):
if (fitnesses[i] < fitness and i != index):
xi += self.calculate_convergence(xi, fireflies[i])
return xi
def random_movement(self, x, t, T):
max_movement = self.Alpha*(1-(t/float(T)))*0.5
if (np.random.rand(1) > 0.5):
if x + max_movement > 1:
movement = (1-x) * np.random.rand(1)
else:
movement = max_movement * np.random.rand(1)
else:
if x - max_movement < 0:
movement = (0-x) * np.random.rand(1)
else:
movement = max_movement * np.random.rand(1) * -1.0
return x + movement
def random_movements(self, x, t, T):
for i in range (0, self.N):
x[i] = self.random_movement(x[i], t, T)
return x
def run(self):
self.totalList = [[] for i in range(0, self.T)]
for t in range (1, self.T):
crap = 0
for i in self.fireflies:
for j in i:
if j < 0 or j > 1:
print "Bounds error"
for i in range(0, self.Nff):
self.fireflies[i] = self.total_convergence(i, self.fireflies, self.fitnesses)
for i in range(0, self.Nff):
self.fireflies[i] = self.random_movements(self.fireflies[i], t, self.T)
for i in range(0, self.Nff):
self.fireflies[i] = np.sort(self.fireflies[i])
self.responses[i] = self.response_model.angleSpectrum(self.fireflies[i])
self.fitnesses[i] = self.response_model.calculateFitness(functions.convertDb(self.responses[i]))
self.average_fitnesses_over_time[t] = np.mean(self.fitnesses)
return self.fireflies, self.responses, self.fitnesses
class Firefly:
def __init__(self, n=10, nff=100, alpha=1.0/80.0, gamma=10.0, t=100):
self.N = n
self.Nff = nff
self.Alpha = alpha
self.Gamma = gamma
self.T = t
np.random.seed()
def response_model(self, k=5*np.pi, n=10, angle_increment=128, peakWidth=28.0/180.0*np.pi, sidelobeHeight=-24):
self.response_model = ResponseModel(k, n, angle_increment, peakWidth, sidelobeHeight)
self.spacing_model = SpacingModel((1.0 / k * np.pi / 2.0), self.N)
def generate_initials(self):
# self.fireflies = [np.sort(np.random.rand(self.N)) for i in range (0, self.Nff)]
self.generateFireflies()
self.responses = [self.response_model.angleSpectrum(self.fireflies[j]) for j in range (0, self.Nff)]
self.response_constraint = self.response_model.getRt()
self.fitnesses = [self.response_model.calculateFitness(functions.convertDb(self.responses[k])) for k in range (0, self.Nff)]
self.averageFitnessOverTime = [0 for l in range (0, self.T)]
self.averageFitnessOverTime[0] = np.mean(self.fitnesses)
self.separations = [self.spacing_model.calculateSpacings(self.fireflies[i]) for i in range (0, self.Nff)]
self.goodSeparationCount = [self.spacing_model.checkSpacings(self.separations[i]) for i in range (0, self.Nff)]
self.averageGoodSeparationOverTime = np.empty(self.T)
self.averageGoodSeparationOverTime[0] = np.mean(self.goodSeparationCount)
self.averagePositionsOverTime = np.array([np.empty(self.N) for i in range (0, self.T)])
self.averagePositionsOverTime[0] = np.mean(self.fireflies, axis=0)
def generateFireflies(self):
top = self.spacing_model.MAX_CONSTRAINT
bottom = self.spacing_model.MIN_CONSTRAINT
scale = top-bottom
# print top, bottom, scale
self.fireflies = [np.fromfunction(lambda i: bottom+top*i, (self.N,)) + (scale*np.random.rand(self.N))for j in range (0, self.Nff)]
# print self.fireflies
def calculate_convergence(self, xi=[], xt=[]):
distance = functions.distance(self.N,xi,xt)
xn = (np.exp(-self.Gamma*(distance**2)))* (xt-xi)
return xn
def total_convergence(self, index, fireflies, fitnesses):
fitness = fitnesses[index]
xi = fireflies[index]
goodSeparationCount = self.goodSeparationCount[index]
for i in range (0, self.Nff):
if (fitnesses[i] < fitness and i != index and goodSeparationCount < self.goodSeparationCount[i]):
xi += self.calculate_convergence(xi, fireflies[i])
return xi
def randomMovementMagnitude(self, t, T):
max_movement = self.Alpha*(1-(t/float(T)))*0.5
return max_movement
def random_movement(self, maxDown, maxUp, magnitude):
if (np.random.rand(1) > 0.5):
if magnitude > maxUp:
movement = maxUp * np.random.rand(1)
else:
movement = magnitude * np.random.rand(1)
else:
if magnitude > maxDown:
movement = maxDown * np.random.rand(1) * -1.0
else:
movement = magnitude * np.random.rand(1) * -1.0
return movement
def random_movements(self, x, spacings, t, T):
magnitude = self.randomMovementMagnitude(t, T)
# print x
# print spacings
for i in range (0, self.N):
maxDown = max(spacings[i] - self.spacing_model.MIN_DISTANCE, 0.0)
maxUp = max(spacings[i+1] - self.spacing_model.MIN_DISTANCE, 0.0)
if i == self.N-1:
maxUp = spacings[i+1]
# print i, maxDown, maxUp
x[i] = x[i] + self.random_movement(maxDown, maxUp, magnitude)
return x
def run(self):
self.totalList = [[] for i in range(0, self.T)]
for t in range (1, self.T):
# for i in self.fireflies:
# for j in i:
# if j < 0 or j > 1:
# print "Bounds error"
for i in range(0, self.Nff):
self.fireflies[i] = self.total_convergence(i, self.fireflies, self.fitnesses)
for i in range(0, self.Nff):
self.separations[i] = self.spacing_model.calculateSpacings(self.fireflies[i])
self.fireflies[i] = self.random_movements(self.fireflies[i], self.separations[i], t, self.T)
self.fireflies[i] = np.sort(self.fireflies[i])
self.responses[i] = self.response_model.angleSpectrum(self.fireflies[i])
self.fitnesses[i] = self.response_model.calculateFitness(functions.convertDb(self.responses[i]))
self.separations[i] = self.spacing_model.calculateSpacings(self.fireflies[i])
self.goodSeparationCount[i] = self.spacing_model.checkSpacings(self.separations[i])
self.averageGoodSeparationOverTime[t] = np.mean(self.goodSeparationCount)
self.averageFitnessOverTime[t] = np.mean(self.fitnesses)
self.averagePositionsOverTime[t] = np.mean(self.fireflies, axis=0)
return self.fireflies, self.responses, self.fitnesses, self.goodSeparationCount, self.averageGoodSeparationOverTime, self.averageFitnessOverTime, self.averagePositionsOverTime
def response_model(self, k=5*np.pi, n=10, angle_increment=128, peakWidth=28.0/180.0*np.pi, sidelobeHeight=-24):
self.response_model = ResponseModel(k, n, angle_increment, peakWidth, sidelobeHeight)
self.spacing_model = SpacingModel((1.0 / k * np.pi / 2.0), self.N)
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from pandas.tools import plotting
from scipy import stats
from functions import ResponseModel
import functions
if __name__ == "__main__":
model = ResponseModel()
filename = "data/2018-07-19_09.42/"
# filename = "data/2018-07-27_16.40/"
filename = "data/2018-08-02_16.32/"
dfx = pd.read_csv(filename + "x.csv", header=None)
dff = pd.read_csv(filename + "fitness.csv", header=None)
dfff = dff.values.flatten()
dropIndexs = []
fig = plt.figure()
count = 0
for i, val in enumerate(dfff):
antenna = dfx.iloc[i]
antenna = antenna.as_matrix()
response = model.angleSpectrum(antenna)
fitness = model.calculateFitness(functions.convertDb(response))
if fitness > 0.01:
dropIndexs.append(i)
count += 1
class RandomSamplingModel:
def __init__(self, k=5*np.pi, n=10, angle_increment=128, sample_size=100, alpha=0.1):
self.K = k
self.N = n
self.N_phi = angle_increment
self.SAMPLES = sample_size
self.response_model()
self.Alpha = alpha
def response_model(self, k=5*np.pi, n=10, angle_increment=128, peakWidth=28.0/180.0*np.pi, sidelobeHeight=-24):
self.response_model = ResponseModel(k, n, angle_increment, peakWidth, sidelobeHeight)
def modeledResponse(self, phi):
u = self.phi2u(phi)
mu = np.sin(u) / u
return mu
def modelededResponseVariance(self, phi, n):
u = self.phi2u(phi)
# sinc = np.sin(u) / u
sigma = (0.5 + (np.sin(2*u) / (4*u)) - ((np.sin(u) / u) ** 2)) / n
return sigma
def phi2u(self, phi):
u = 5 * np.pi * np.cos(phi)
return u
def generateModeledResponse(self):
angle = 0
index = 0
mu = np.zeros(self.N_phi)
while index < self.N_phi:
mu[index] = self.modeledResponse(angle)
angle += np.pi / self.N_phi
index += 1
return mu
def generateModeledVariance(self):
angle = 0
index = 0
sigma = [0 for i in range(0, self.N_phi)]
while index < self.N_phi:
sigma[index] = self.modelededResponseVariance(angle, self.N)
angle += np.pi / float(self.N_phi)
index += 1
return sigma
def get_dataset(self):
filename = "data/2018-07-19_09.42/"
dfx = pd.read_csv(filename + "x.csv", header=None)
return dfx
def generateCDF(self, dataset):
count, bins = np.histogram(dataset, bins=128, range=[0, 1], density=True)
cdf = np.cumsum(count) / self.N_phi
return cdf
def sampleCDF(self, cdf):
rand = np.random.rand()
index = 0
current = cdf[index]
while current < rand:
index += 1
current = cdf[index]
return current
def samplePercentileRange(self, min, max, length):
dif = max - min
rand = np.random.rand(length)
scaled = rand * dif
finished = scaled + min
return finished
def checkRandomUniformSampling(self):
fireflies = np.array([np.random.rand(self.N) for i in range (0, self.SAMPLES)])
count, bins = np.histogram(fireflies, bins=128, range=[0, 1], density=True)
plt.plot(bins[:-1], count)
plt.xlim([0,1])
plt.show()
responses = np.empty([self.SAMPLES,self.N_phi])
fitnesses = np.empty(self.SAMPLES)
for index in range (0, self.SAMPLES):
firefly = fireflies[index]
responses[index] = self.response_model.angleSpectrum(firefly)
fitnesses[index] = self.response_model.calculateFitness(functions.convertDb(responses[index]))
averageResponse = np.mean(responses, axis=0)
variance = np.var(responses, axis=0)
modeledAverage = self.generateModeledResponse()
modeledVariance = self.generateModeledVariance()
meanFitness = np.mean(fitnesses)
mse = ((averageResponse - modeledAverage) ** 2).mean(axis=None)
DbAverageResponse = functions.convertDb(np.mean(responses, axis=0))
DbModeledAverage = functions.convertDb(self.generateModeledResponse())
fig = plt.figure()
angleSpectrum = [(i*1.0/self.N_phi*180) for i in range (0, self.N_phi)]
plt.plot(angleSpectrum, DbAverageResponse, label="Simulation")
plt.plot(angleSpectrum, DbModeledAverage, label="Analytical Model")
plt.plot(angleSpectrum, self.response_model.getRt(), label="Desired")
plt.title("Mean Response Generated from\nRandom Uniform Sampling for Antenna Element Positions")
plt.legend()
plt.ylabel("Response (dB)")
plt.xlabel("Angle (degrees)")
plt.ylim([-65,5])
plt.show()
plt.plot(variance, label="Simulation")
plt.plot(modeledVariance, label="Analytical Model")
plt.legend()
plt.show()
return mse, DbAverageResponse
def sampleUsingPercentileRanges(self):
dfx = self.get_dataset()
mins = np.percentile(dfx, 10.0, axis=0)
medians = np.percentile(dfx, 50.0, axis=0)
maxs = np.percentile(dfx, 90.0, axis=0)
fireflies = np.array([self.samplePercentileRange(mins, maxs, self.N) for i in range (0, self.SAMPLES)])
for i in range (0, 10):
x = fireflies[:,i]
count, bins = np.histogram(x, bins=128, range=[0, 1], density=True)
plt.plot(bins[:-1], count)
plt.xlim([0,1])
plt.show()
responses = np.empty([self.SAMPLES,self.N_phi])
fitnesses = np.empty(self.SAMPLES)
for index in range (0, self.SAMPLES):
firefly = fireflies[index]
responses[index] = self.response_model.angleSpectrum(firefly)
fitnesses[index] = self.response_model.calculateFitness(functions.convertDb(responses[index]))
averageResponse = functions.convertDb(np.mean(responses, axis=0))
variance= np.var(responses, axis=0)
medianResponse = functions.convertDb(self.response_model.angleSpectrum(medians))
meanFitness = np.mean(fitnesses)
fig = plt.figure()
plt.plot(averageResponse, label="Mean Sampling from Range 10th to 90th Percentile")
plt.plot(medianResponse, label="Response From Median")
plt.plot(self.response_model.getRt(), label="Desired")
plt.legend()
plt.ylim([-65,5])
plt.show()
plt.plot(variance, label="Simulation")
plt.legend()
plt.show()
return meanFitness, averageResponse
def sampleFromCDF(self):
dfx = self.get_dataset()
cdf = self.generateCDF(dfx)
fireflies = np.array([np.array([self.sampleCDF(cdf) for j in range (0, self.N)]) for i in range (0, self.SAMPLES)])
count, bins = np.histogram(fireflies, bins=128, range=[0, 1], density=True)
plt.plot(bins[:-1], count)
plt.xlim([0,1])
plt.show()
responses = np.empty([self.SAMPLES,self.N_phi])
fitnesses = np.empty(self.SAMPLES)
for index in range (0, self.SAMPLES):
firefly = fireflies[index]
responses[index] = self.response_model.angleSpectrum(firefly)
fitnesses[index] = self.response_model.calculateFitness(functions.convertDb(responses[index]))
averageResponse = np.mean(responses, axis=0)
variance = np.var(responses, axis=0)
modeledAverage = self.generateModeledResponse()
modeledVariance = self.generateModeledVariance()
meanFitness = np.mean(fitnesses)
mse = ((averageResponse - modeledAverage) ** 2).mean(axis=None)
DbAverageResponse = functions.convertDb(np.mean(responses, axis=0))
DbModeledAverage = functions.convertDb(self.generateModeledResponse())
fig = plt.figure()
plt.plot(DbAverageResponse, label="Mean from CDF Sampled Antenna")
plt.plot(DbModeledAverage, label="Random Uniform Sampling")
plt.plot(self.response_model.getRt(), label="Desired")
plt.legend()
plt.ylim([-65,5])
plt.show()
plt.plot(variance, label="Simulation")
plt.plot(modeledVariance, label="Random Uniform Sampling")
plt.legend()
plt.show()
return mse, DbAverageResponse