markdown
stringlengths 0
1.02M
| code
stringlengths 0
832k
| output
stringlengths 0
1.02M
| license
stringlengths 3
36
| path
stringlengths 6
265
| repo_name
stringlengths 6
127
|
|---|---|---|---|---|---|
计算信息熵 | def entropy(y):
precs = np.array(list(Counter(y).values()))/len(y)
ent = np.sum(-1 * precs * np.log(precs))
return ent
entropy(y_train) | _____no_output_____ | MIT | DecisionTree/MyDecisionTree.ipynb | QYHcrossover/ML-numpy |
决定使用哪个特征分割 | def decide_feature(X,y,feature_order):
n_features = X.shape[-1]
ents = (feature_order != -1).astype(np.float64)
for i in range(n_features):
if feature_order[i] >= 0:
continue
for feature,size in Counter(X[:,i]).items():
index = (X[:,i] == feature)
splity = y[index]
ent = entropy(splity)
ents[i] += ent*size/len(X)
fi = np.argmin(ents)
return fi,ents[fi]
decide_feature(X_train,y_train,np.array([-1,-1,-1,-1])) | _____no_output_____ | MIT | DecisionTree/MyDecisionTree.ipynb | QYHcrossover/ML-numpy |
构建决策树 | def build_tree(X,y,feature_order):
curent = entropy(y)
counts = dict(Counter(y))
if len(counts) == 1 or min(feature_order) == 0:
result = max(counts,key=counts.get)
return {"counts":counts,"result":result}
fi,ent = decide_feature(X,y,feature_order)
feature_order[fi] = max(feature_order)+1
result = None
next_ = {}
for value,_ in Counter(X[:,fi]).items():
next_[value] = build_tree(X[X[:,fi]==value],y[X[:,fi]==value],feature_order)
return {"feature":fi,"entgain":curent-ent,"counts":counts,"result":result,"next":next_}
tree = build_tree(X_train,y_train,np.array([-1,-1,-1,-1]))
tree | 是 6
否 8
是 2
否 6
| MIT | DecisionTree/MyDecisionTree.ipynb | QYHcrossover/ML-numpy |
predict | x_test = X_test[0]
print(x_test)
while tree["result"] == None:
feature = tree["feature"]
nexttree = tree["next"][x_test[feature]]
tree = nexttree
print(tree["result"])
class ID3DecisionTree:
@staticmethod
def entropy(y):
precs = np.array(list(Counter(y).values()))/len(y)
ent = np.sum(-1 * precs * np.log(precs))
return ent
def decide_feature(self,X,y,feature_order):
n_features = X.shape[-1]
ents = (feature_order != -1).astype(np.float64)
for i in range(n_features):
if feature_order[i] >= 0:
continue
for feature,size in Counter(X[:,i]).items():
index = (X[:,i] == feature)
splity = y[index]
ent = ID3DecisionTree.entropy(splity)
ents[i] += ent*size/len(X)
fi = np.argmin(ents)
return fi,ents[fi]
def build_tree(self,X,y,feature_order):
curent = ID3DecisionTree.entropy(y)
counts = dict(Counter(y))
if len(counts) == 1 or min(feature_order) == 0:
result = max(counts,key=counts.get)
return {"counts":counts,"result":result}
fi,ent = self.decide_feature(X,y,feature_order)
feature_order[fi] = max(feature_order)+1
result = None
next_ = {}
for value,_ in Counter(X[:,fi]).items():
next_[value] = self.build_tree(X[X[:,fi]==value],y[X[:,fi]==value],feature_order)
return {"feature":fi,"entgain":curent-ent,"counts":counts,"result":result,"next":next_}
def fit(self,X,y):
feature_order = -1 * np.ones(X.shape[-1])
self.tree = self.build_tree(X,y,feature_order)
def predict(self,X):
y = []
for i in range(len(X)):
x_test = X[i]
tree = self.tree
while tree["result"] == None:
feature = tree["feature"]
nexttree = tree["next"][x_test[feature]]
tree = nexttree
y.append(tree["result"])
return y
dt = ID3DecisionTree()
dt.fit(X_train,y_train)
dt.predict(X_test) | _____no_output_____ | MIT | DecisionTree/MyDecisionTree.ipynb | QYHcrossover/ML-numpy |
Genetic algorithmThe implementation uses the inver-over genetic operator to optimize the static sequence of debris based on the transference cost of the arcs.Also, the implementation uses **index_frozen** to model the already deorbited debris. | class GA:
def __init__(self, population, fn_fitness, subpath_fn_fitness=None):
self.population = population
self.index_frozen = -1
self.fitnesses = [] # fitness for each individual in population
self.fn_fitness = fn_fitness # fitness function for the whole path
self.subpath_fn_fitness = subpath_fn_fitness # fitness function for a subpath
# freezes a debris in all individuals
def freeze_first(self, frozen):
self.index_frozen += 1
for i in range(len(self.population)):
del self.population[i][self.population[i].index(frozen)]
self.population[i].insert(self.index_frozen, frozen)
# decay a debris in all individuals
def decay(self, decayed_debris):
for i in range(len(self.population)):
for x in decayed_debris:
if x in self.population[i]:
del self.population[i][self.population[i].index(x)]
# force a first debris for all individuals
def startBy(self, debris):
for i in range(len(self.population)):
pos = self.population[i].index(debris)
self.population[i] = self.population[i][pos:] + self.population[i][:pos]
# returns the best individual
def getBest(self):
self.fit_population()
best = min(self.fitnesses)
return self.population[self.fitnesses.index(best)]
# run the inverover to optimize the static case
"""
tinv : int : number of iterations
feach : int : milestone to run kopt on the population
runkopt : int : iterations of kopt
forn : int : how many of the best individuals goes to kopt
"""
def run_inverover(self, tinv=1000, feach=1000, runkopt=100, forn=None):
self.fit_population()
self.inver_over(tinv, feach, runkopt, forn)
self.fit_population()
best = min(self.fitnesses)
return self.population[self.fitnesses.index(best)]
# select a random element of the population
def selectUniform(self):
return self.population[random.randrange(0, len(self.population))]
# calculate the fitness for all individuals
def fit_population(self):
if self.index_frozen >= 0:
self.fitnesses = list(map(lambda x: self.subpath_fn_fitness(x[self.index_frozen:]), self.population))
else:
self.fitnesses = list(map(lambda x: self.fn_fitness(x), self.population))
# run the stochastic kopt for the population
"""
permuts : int : number of iterations
elite : int : how many of the best shoud be processed
"""
def koptStochastic(self, permuts=100, elite=None):
indexes = range(len(self.population))
if elite is not None:
indexes = numpy.array(self.fitnesses).argsort()[:elite]
for x in indexes:
indv = self.population[x]
useds = {}
changed = False
for _ in range(0, permuts):
valid = False
while not valid:
i = random.randrange(self.index_frozen+1, len(indv))
j = i
while j == i: j = random.randrange(self.index_frozen+1, len(indv))
if (i, j) not in useds:
valid = True
useds[(i, j)] = True
if j < i:
temp = i
i = j
j = temp
if self.subpath_fn_fitness(list(reversed(indv[i:j+1]))) < self.subpath_fn_fitness(indv[i:j+1]):
changed = True
indv = indv[0:i] + list(reversed(indv[i:j+1])) + indv[j+1:]
if changed:
self.population[x] = indv
self.fitnesses[x] = self.subpath_fn_fitness(indv[self.index_frozen+1:])
# run the ranged kopt for one individual
"""
indv : array : the individual
maxrange : int : the range of analysis around the individual
"""
def ranged2opt(self, indv, maxrange=10):
ranger = indv[len(indv)-maxrange:] + indv[self.index_frozen+1: self.index_frozen+maxrange+2]
if len(set(ranger)) != len(ranger):
return indv
fit = self.subpath_fn_fitness(ranger)
changed = True
while changed:
changed = False
for i in range(len(ranger)):
for j in range(len(ranger)):
new_ranger = ranger[0:i] + list(reversed(ranger[i:j+1])) + ranger[j+1:]
new_fit = self.subpath_fn_fitness(new_ranger)
if new_fit < fit:
fit = new_fit
ranger = new_ranger
changed = True
break
if changed:
break
indv[len(indv)-maxrange:] = ranger[:maxrange]
indv[self.index_frozen+1: self.index_frozen+maxrange+2] = ranger[maxrange:]
return indv
# run the inverover for the population
"""
tinv : int : number of iterations
feach : int : milestone to run kopt on the population
runkopt : int : iterations of kopt
forn : int : how many of the best individuals goes to kopt
"""
def inver_over(self, tinv, feach, runkopt, forn):
for w in range(tinv):
if w % feach == 0:
self.koptStochastic(runkopt, forn)
for i in range(len(self.population)):
tmp = self.population[i]
c1 = tmp[random.randrange(0, len(tmp))]
changed = False
while True:
sl = self.population[i]
c2 = c1
while sl == self.population[i]: sl = self.selectUniform()
c2 = sl[(sl.index(c1) + 1) % len(sl)]
pos_c1 = tmp.index(c1)
pos_c2 = tmp.index(c2)
# if the genes are adjacent
if c2 in [ tmp[pos_c1-1], tmp[(pos_c1 + 1) % len(tmp)] ]:
break
# elif and else reverse a subset of chromosome
elif pos_c2 > pos_c1:
changed = True
c1 = tmp[(pos_c2 + 1) % len(tmp)]
tmp = tmp[:pos_c1+1] + list(reversed(tmp[pos_c1+1:pos_c2+1])) + tmp[pos_c2+1:]
else:
changed = True
c1 = tmp[pos_c2-1]
inverted = list(reversed(tmp[pos_c1:] + tmp[:pos_c2]))
div_pos = len(tmp)-pos_c1
tmp = inverted[div_pos:] + tmp[pos_c2:pos_c1] + inverted[:div_pos]
if changed:
fit_tmp = self.fn_fitness(tmp)
if fit_tmp < self.fitnesses[i]:
self.population[i] = tmp
self.fitnesses[i] = fit_tmp | _____no_output_____ | MIT | ActiveDebrisRemoval.ipynb | jbrneto/active-debris-removal |
Problem instanceThe active debris removal problem is going to be modeled as a complex variant of Traveling Salesman Problem (TSP), the time-dependent TSP (TDTSP).The debris are the nodes and the dynamic transference trajectories are the edges.Also, the Max Open Walk is used to find for the optimized subpath. | class StaticDebrisTSP:
mu = 398600800000000 # gravitational parameter of earth
re = 6378100 # radius of earth
def __init__(self, debris=[], weight_matrix=[], reward_matrix=[], path_size=0, population_size=100, epoch=None, hohmanncost=False):
self.index_frozen = -1
self.debris = debris # the debris cloud
self.reward_matrix = reward_matrix # the removal reward per debris
self.kepler_elements = [] # kepler elements of the debris
self.decayed_debris = [] # decayed debris
self.hohmanncost=hohmanncost # if the cost is calculated with hohmann
if epoch is not None:
self.epoch = epoch
else:
epoch = pykep.epoch_from_string("2021-06-11 00:06:09")
is_matrix = len(weight_matrix) != 0
# size of a indivual
self.size = path_size if path_size != 0 else (len(weight_matrix) if is_matrix else len(debris))
# random population that will be used just as an input for the GA
self.population = []
for i in range(0, population_size):
self.population.append(random.sample(range(0, self.size), self.size))
# eighter receive the weight matrix or calculate it
if is_matrix:
self.fitness_matrix = weight_matrix
else:
# remove decayed debris
i = 0
count = 0
qtd_decayed = 0
while count < self.size:
if i >= len(debris):
break
try:
self.kepler_elements.append(debris[i].osculating_elements(self.epoch))
count += 1
except:
self.decayed_debris.append(i)
qtd_decayed += 1
i += 1
print('Decayed debris ', qtd_decayed, 'Total ', len(self.kepler_elements))
if len(self.kepler_elements) < self.size:
raise BaseException('Insuficient size')
# fitness matrix
self.fitness_matrix = numpy.zeros((self.size, self.size))
for i in range(0, self.size):
for j in range(0, self.size):
if self.hohmanncost:
self.fitness_matrix[i][j] = StaticDebrisTSP.MYhohmann_impulse_aprox(self.kepler_elements[i], self.kepler_elements[j], self.epoch)
else:
try:
self.fitness_matrix[i][j] = pykep.phasing.three_impulses_approx(debris[i], debris[j], self.epoch, self.epoch)
except:
d1 = self.kepler_elements[i]
d2 = self.kepler_elements[j]
self.fitness_matrix[i][j] = StaticDebrisTSP.MYthree_impulse_aprox(d1[0],d1[1],d1[2],d1[3],d2[0],d2[1],d2[2],d2[3],StaticDebrisTSP.mu)
# freezes the first element
def freeze_first(self):
self.index_frozen += 1
# returns if all debris were removed
def all_frozen(self):
return self.index_frozen >= (self.size-1-len(self.decayed_debris))
# transform the debris kepler elements to certain epoch
"""
dt_epoch : datetime : the target epoch
indexes : array : the debris that should be transformed
"""
def to_epoch(self, dt_epoch, indexes):
new_epoch = pykep.epoch_from_string(dt_epoch.strftime(FMT))
ranger = [x for x in range(0, self.size) if x in indexes]
self.kepler_elements = list(numpy.zeros(self.size))
for j in ranger:
try:
self.kepler_elements[j] = debris[j].osculating_elements(new_epoch)
except:
self.decayed_debris.append(j)
for x in self.decayed_debris:
if x in ranger:
del ranger[ranger.index(x)]
for i in ranger:
for j in ranger:
if self.hohmanncost:
self.fitness_matrix[i][j] = StaticDebrisTSP.MYhohmann_impulse_aprox(self.kepler_elements[i], self.kepler_elements[j], new_epoch)
else:
try:
self.fitness_matrix[i][j] = pykep.phasing.three_impulses_approx(debris[i], debris[j], new_epoch, new_epoch)
except:
d1 = self.kepler_elements[i]
d2 = self.kepler_elements[j]
self.fitness_matrix[i][j] = StaticDebrisTSP.MYthree_impulse_aprox(d1[0],d1[1],d1[2],d1[3],d2[0],d2[1],d2[2],d2[3],StaticDebrisTSP.mu)
for x in self.decayed_debris:
if x in indexes:
del indexes[indexes.index(x)]
return indexes
# fitness is the sum cost to travel between each I and I+1 plus the last to initial
def fitness(self, solution):
fit = 0
for i in range(0, self.size-1):
fit += self.fitness_matrix[solution[i]][solution[i+1]]
fit += self.fitness_matrix[solution[self.size-1]][solution[0]]
return fit
# partial fitness is the sum cost to travel between each I and I+1
def partialFitness(self, part):
fit = 0
for i in range(0, len(part)-1):
fit += self.fitness_matrix[part[i]][part[i+1]]
return fit
# reward is the sum reward of the debris in the solution
def reward(self, solution):
reward = 0
for i in range(0, len(solution)):
reward += self.reward_matrix[solution[i]]
return reward
# estimate the duration of a solution
def duration(self, solution):
duration = 0
for i in range(0, len(solution)-1):
duration += self.transferDuration(solution[i], solution[i+1], StaticDebrisTSP.mu)
return duration
# fitness TD is the fitness function for a timedependent solution
def fitnessTD(self, solution):
if len(solution) < 2:
return 0
fit = 0
for i in range(0, len(solution)-1):
epoch = pykep.epoch_from_string((solution[i+1][0]).strftime(FMT))
if self.hohmanncost:
d1 = debris[solution[i][1]].osculating_elements(epoch)
d2 = debris[solution[i+1][1]].osculating_elements(epoch)
fit += StaticDebrisTSP.MYhohmann_impulse_aprox(d1, d2, epoch)
else:
try:
fit += pykep.phasing.three_impulses_approx(debris[solution[i][1]], debris[solution[i+1][1]], epoch, epoch)
except:
d1 = debris[solution[i][1]].osculating_elements(epoch)
d2 = debris[solution[i+1][1]].osculating_elements(epoch)
fit += StaticDebrisTSP.MYthree_impulse_aprox(d1[0],d1[1],d1[2],d1[3],d2[0],d2[1],d2[2],d2[3],StaticDebrisTSP.mu)
return fit
# duration TD is the duration estimate for a timedependent solution
def durationTD(self, solution):
duration = 0
for i in range(0, len(solution)-1):
duration += (solution[i+1][0] - solution[i][0]).total_seconds() # seconds waiting for right epoch
epoch = pykep.epoch_from_string(solution[i+1][0].strftime(FMT))
duration += self.transferDurationTD(solution[i][1], solution[i+1][1], epoch, epoch, StaticDebrisTSP.mu)
return duration
# reward TD is the reward function for a timedependent solution
def rewardTD(self, solution):
reward = 0
for i in range(0, len(solution)):
reward += self.reward_matrix[solution[i][1]]
return reward
# estimate the duration of a transfer (Hohmann) in seconds
def transferDuration(self, d1, d2, u):
d1_semi_major_axis = self.kepler_elements[d1][0]
d2_semi_major_axis = self.kepler_elements[d2][0]
transfer_semi_major_axis = (d1_semi_major_axis + d2_semi_major_axis) / 2
time_of_transfer = math.pi * math.sqrt((transfer_semi_major_axis**3) / u)
return time_of_transfer
# estimate the duration of a transfer (Hohmann) in seconds in a certain epoch
def transferDurationTD(self, d1, d2, epoch1, epoch2, u):
kepler1 = debris[d1].osculating_elements(epoch1)
kepler2 = debris[d2].osculating_elements(epoch2)
d1_semi_major_axis = kepler1[0]
d2_semi_major_axis = kepler2[0]
transfer_semi_major_axis = (d1_semi_major_axis + d2_semi_major_axis) / 2
time_of_transfer = math.pi * math.sqrt((transfer_semi_major_axis**3) / u)
return time_of_transfer
# find the constrained embedded maximal rewardable path in a solution
def maxOpenWalk(self, solution, cost_limit=1000, time_limit=31536000):
# calculate transferences
transfers = []
durations = []
for i in range(0, len(solution)-1):
sol_i = solution[i]
sol_j = solution[i+1]
transfers.append(self.fitness_matrix[sol_i][sol_j])
durations.append(self.transferDuration(sol_i, sol_j, StaticDebrisTSP.mu))
# calculate the maximal open walks starting at each arc
maxWalks = []
for i in range(0, len(transfers)):
cost = transfers[i]
duration = durations[i]
walk = [i]
for j in range(i+1, len(transfers)):
if (cost + transfers[j]) > cost_limit or (duration + durations[j]) > time_limit:
break;
else:
cost += transfers[j]
duration += durations[j]
walk.append(j)
nodes = []
reward = 0
for a in range(0, len(walk)):
arc = walk[a]
if solution[arc] not in nodes:
nodes.append(solution[arc])
reward += self.reward_matrix[solution[arc]]
nodes.append(solution[arc+1])
reward += self.reward_matrix[solution[arc+1]]
maxWalks.append({'walk': nodes, 'cost': cost, 'duration': duration, 'reward': reward})
# find the biggest open walk
w = 0
for i in range(1, len(maxWalks)):
if maxWalks[i]['reward'] > maxWalks[w]['reward']:
w = i
return maxWalks[w]
# find the constrained embedded maximal rewardable path in a timedependent solution
def maxOpenWalkTD(self, solution, cost_limit=1000, time_limit=31536000):
# calculate transferences
transfers = []
durations = []
for i in range(0, len(solution)-1):
epoch = pykep.epoch_from_string((solution[i+1][0]).strftime(FMT))
sol_i = solution[i][1]
sol_j = solution[i+1][1]
duration = (solution[i+1][0] - solution[i][0]).total_seconds() # seconds waiting for right epoch
duration += self.transferDurationTD(sol_i, sol_j, epoch, epoch, StaticDebrisTSP.mu)
durations.append(duration)
if self.hohmanncost:
d1 = debris[sol_i].osculating_elements(epoch)
d2 = debris[sol_j].osculating_elements(epoch)
transfers.append(StaticDebrisTSP.MYhohmann_impulse_aprox(d1, d2, epoch))
else:
try:
transfers.append(pykep.phasing.three_impulses_approx(debris[sol_i], debris[sol_j], epoch, epoch))
except:
d1 = debris[sol_i].osculating_elements(epoch)
d2 = debris[sol_j].osculating_elements(epoch)
transfers.append(StaticDebrisTSP.MYthree_impulse_aprox(d1[0],d1[1],d1[2],d1[3],d2[0],d2[1],d2[2],d2[3],StaticDebrisTSP.mu))
# calculate the maximal open walks starting at each arc
maxWalks = []
for i in range(0, len(transfers)):
cost = transfers[i]
duration = durations[i]
walk = [i]
for j in range(i+1, len(transfers)):
if (cost + transfers[j]) > cost_limit or (duration + durations[j]) > time_limit:
break;
else:
cost += transfers[j]
duration += durations[j]
walk.append(j)
nodes = []
reward = 0
for a in range(0, len(walk)):
arc = walk[a]
if solution[arc] not in nodes:
nodes.append(solution[arc])
reward += self.reward_matrix[solution[arc][1]]
nodes.append(solution[arc+1])
reward += self.reward_matrix[solution[arc+1][1]]
maxWalks.append({'walk': nodes, 'cost': cost, 'duration': duration, 'reward': reward})
# find the biggest open walk
w = 0
for i in range(1, len(maxWalks)):
if maxWalks[i]['reward'] > maxWalks[w]['reward']:
w = i
return maxWalks[w]
# estimate the hohmann cost for a transfer between two debris
# kepler elements order: a,e,i,W,w,M
def MYhohmann_impulse_aprox(kepler1, kepler2):
if kepler1 == kepler2:
return 0
d1 = math.sqrt(StaticDebrisTSP.mu/kepler1[0]) * (math.sqrt((2*kepler2[0]) / (kepler1[0]+kepler2[0])) - 1)
d2 = math.sqrt(StaticDebrisTSP.mu/kepler2[0]) * (- math.sqrt((2*kepler1[0]) / (kepler1[0]+kepler2[0])) + 1)
dv = abs(d1 + d2)
re = - StaticDebrisTSP.mu / (2 * (StaticDebrisTSP.re + kepler2[0]))
rvi = math.sqrt(2 * ( (StaticDebrisTSP.mu / (StaticDebrisTSP.re + kepler2[0])) + re))
romega = abs(math.degrees(kepler2[2]) - math.degrees(kepler1[2]))
rdv = 2 * rvi * math.sin(romega/2)
return abs(dv + rdv)
# estimate the edelbaum cost for a transfer between two debris
# this implementation replaces the pykep implementation, since pykep throws an exception for decayed debris
def MYthree_impulse_aprox(a1, e1, i1, W1, a2, e2, i2, W2, mu):
# radius of apocenter/pericenter starting orbit (ms)
ra1 = a1 * (1 + e1);
ra2 = a2 * (1 + e2);
rp1 = a1 * (1 - e2);
rp2 = a2 * (1 - e2);
# relative inclination between orbits
cosiREL = math.cos(i1) * math.cos(i2) + math.sin(i1) * math.sin(i2) * math.cos(W1 - W2)
# Strategy is Apocenter-Pericenter
if ra1 > ra2:
Vi = math.sqrt(mu * (2.0 / ra1 - 1.0 / a1));
Vf = math.sqrt(mu * (2.0 / ra1 - 2.0 / (rp2 + ra1)));
# Change Inclination + pericenter change
DV1 = math.sqrt(Vi * Vi + Vf * Vf - 2.0 * Vi * Vf * cosiREL);
# Apocenter Change
DV2 = math.sqrt(mu) * abs(math.sqrt(2.0 / rp2 - 2.0 / (rp2 + ra1)) - math.sqrt(2.0 / rp2 - 1.0 / a2));
return (DV1 + DV2)
# Strategy is Pericenter-Apocenter
else:
Vi = math.sqrt(mu * ((2 / ra2) - (2 / (rp1 + ra2))));
Vf = math.sqrt(mu * ((2 / ra2) - (1 / a2)));
# Apocenter Raise
DV1 = math.sqrt(mu) * abs(math.sqrt((2 / rp1) - (2 / (rp1 + ra1))) - math.sqrt((2 / rp1) - (2 / (rp1 + ra2))));
# Change Inclination + apocenter change
DV2 = math.sqrt(abs((Vi * Vi) + (Vf * Vf) - (2 * Vi * Vf * cosiREL)));
return (DV1 + DV2) | _____no_output_____ | MIT | ActiveDebrisRemoval.ipynb | jbrneto/active-debris-removal |
Instance loadingThe instances can be downloaded at SATCAT site.It is necessary to use a TXT file (TLE file) to get the debris names, codes and kepler elements, and a CSV file for the debris RCS (reward). | deb_file = 'fengyun-1c-debris'
debris = pykep.util.read_tle(tle_file=deb_file+'.txt', with_name=True)
with open(deb_file+'.txt') as f:
tle_string = ''.join(f.readlines())
tle_lines = tle_string.strip().splitlines()
tle_elements = [tle_lines[i:i + 3] for i in range(0, len(tle_lines), 3)] #split in array of debris
debris_tle = [TLE.from_lines(*tle_elements[i]) for i in range(0, len(tle_elements))]
with open(deb_file+'.csv', newline='') as csvfile:
satcat = list(csv.reader(csvfile))
# extract the reward for each debris
areaDebris = []
norad_index = satcat[0].index('NORAD_CAT_ID')
rcs_index = satcat[0].index('RCS')
for i in range(0, len(debris)):
rcs = 0
for j in range(1, len(satcat)):
if (debris_tle[i].norad == satcat[j][norad_index]):
if (satcat[j][rcs_index]):
rcs = float(satcat[j][rcs_index])
break
areaDebris.append(rcs) | _____no_output_____ | MIT | ActiveDebrisRemoval.ipynb | jbrneto/active-debris-removal |
SolutionHere the actual solution is generated.An interpolated tree search is performed to enhance the static to a time dependent solution. | start_epoch = "2021-06-11 00:06:09"
FMT = '%Y-%m-%d %H:%M:%S'
steps = int((24 * 60) / 10) * 7 # in days
step_size = timedelta(minutes=10)
removal_time = timedelta(days=1) # time taken to deorbit a debris
winsize = 10 # range for the kopt
for _ in range(10):
t0 = datetime.datetime.now() # to track time elapsed
epoch = datetime.datetime.strptime(start_epoch, FMT)
# generate the ga and problem instance
problem = StaticDebrisTSP(epoch=pykep.epoch_from_string(start_epoch), hohmanncost=False, debris=debris, reward_matrix=areaDebris, path_size=size, population_size=100)
ga = GA(population=problem.population, fn_fitness=problem.fitness, subpath_fn_fitness=problem.partialFitness)
# generate the static solution
curr_solution = ga.run_inverover(tinv=20000, feach=1000, runkopt=100, forn=5)
curr_fit = problem.partialFitness(curr_solution)
print('initial fit: '+str(curr_fit))
# find the static max open walk
path = problem.maxOpenWalk(curr_solution, 1000, 60*60*24*365) # 1km/s and 1 year
# make the population start by best starting debris, and get the best then
ga.startBy(path['walk'][0])
curr_solution = ga.getBest()
curr_fit = problem.partialFitness(curr_solution)
print('secondal fit: '+str(curr_fit))
# use the first debris for the time dependent solution
solution = [(epoch, curr_solution[0])]
problem.freeze_first()
ga.freeze_first(curr_solution[0])
while not problem.all_frozen():
i = problem.index_frozen
# run ranged kopt to optimize the current part of solution
if i > 0 and (i < len(curr_solution)-1):
curr_solution[i:i+winsize+1] = problem.to_epoch(epoch, curr_solution[i:i+winsize+1])
curr_solution[-(winsize+1):] = problem.to_epoch(epoch, curr_solution[-(winsize+1):])
ga.decay(problem.decayed_debris)
curr_solution = ga.ranged2opt(curr_solution, winsize)
# get the next transference to be performed
transition = curr_solution[i:i+2]
# validates if the debris in this transference are going to decay in during the interpolation
transition = problem.to_epoch(epoch + (step_size * steps), transition)
if len(transition) < 2:
curr_solution[i:i+2] = transition
ga.decay(problem.decayed_debris)
continue
# calculate the costs of the transference for the interpolation range
epoch_aux = epoch
x = []
y = []
for j in range(0, steps):
problem.to_epoch(epoch, transition)
x.append(j)
y.append(problem.partialFitness(transition))
epoch += step_size
# get the minimal cost point in the interpolated function
interpolator = scipy.interpolate.interp1d(x, y, kind='cubic')
xnew = numpy.linspace(0, steps-1, num=steps*3, endpoint=True) # num = precision
least = numpy.argmin(interpolator(xnew))
# get the epoch of the minimal cost transference
epoch = epoch_aux + (step_size * xnew[least])
# append to the time dependent solution
solution.append((epoch, curr_solution[i+1]))
# pushes the current epoch to after the deorbitation process
pykep_epoch = pykep.epoch_from_string(epoch.strftime(FMT))
transfer_duration = timedelta(seconds=problem.transferDurationTD(curr_solution[i], curr_solution[i+1], pykep_epoch, pykep_epoch, StaticDebrisTSP.mu))
epoch += removal_time + transfer_duration
# freezes the deorbited debris
problem.freeze_first()
ga.freeze_first(curr_solution[i+1])
t1 = datetime.datetime.now()
# instance results
print(solution)
print('elapsed time: '+ str(t1 - t0))
print('fit: ' + str(problem.fitnessTD(solution)))
print('dur: ' + str(problem.durationTD(solution)/60/60/24) + ' days')
print('rew: ' + str(problem.rewardTD(solution)))
# constrained (best mission) results
path = problem.maxOpenWalkTD(solution, 1000, 60*60*24*365) # 1km/s and 1 year
print(path)
print('walk ' + str(len(path['walk'])))
print('w_cost ' + str(path['cost']))
print('w_rew ' + str(path['reward']))
print('w_dur ' + str(path['duration']/60/60/24) + ' days') | _____no_output_____ | MIT | ActiveDebrisRemoval.ipynb | jbrneto/active-debris-removal |
2. Feature SelectionModelAuthor: _Carlos Sevilla Salcedo (Updated: 18/07/2019)_In this notebook we are going to present the extension to include a double sparsity in the model. The idea behind this modification is that besides imposing sparsity in the latent features, we could also force to have sparsity in the input features. This way, the model is capable of not only inferring any data desired, but also carry out a feature selection with a measure of the importance of each feature.The main advantage of this characteristic is two-fold: 1) It allows us to work with lower dimension matrices which, in return, improves the speed of the results. 2) It provides a selection of the most important features which in certain scenarios can considerably improve the interpretability of the results. Synthetic data generationWe can now generate data in a similar manner to the regression model to compare the performance of both apporaches. In this case we are going to include some random features to try to suppress them with the sparse model. | %matplotlib inline
import numpy as np
import matplotlib.pyplot as plt
import math
np.random.seed(0)
N = 1000 # number of samples
D0 = 55 # input features
D1 = 3 # output features
myKc = 20
K = 2 # common latent variables
K0 = 3 # first view's latent variables
K1 = 3 # second view's latent variables
Kc=K+K0+K1 # latent variables
# Generation of matrix W
A0 = np.random.normal(0.0, 1, D0 * K).reshape(D0, K)
A1 = np.random.normal(0.0, 1, D1 * K).reshape(D1, K)
B0 = np.random.normal(0.0, 1, D0 * K0).reshape(D0, K0)
B1 = np.random.normal(0.0, 1, D1 * K1).reshape(D1, K1)
W0 = np.hstack((np.hstack((A0,B0)),np.zeros((D0,K1))))
W1 = np.hstack((np.hstack((A1,np.zeros((D1,K0)))),B1))
W_tot = np.vstack((W0,W1))
# Generation of matrix Z
Z = np.random.normal(0.0, 1, Kc * N).reshape(N, Kc)
# Generation of matrix X
X0 = np.dot(Z,W0.T) + np.random.normal(0.0, 0.1, D0 * N).reshape(N, D0)
X1 = np.dot(Z,W1.T) + np.random.normal(0.0, 0.1, D1 * N).reshape(N, D1)
#Random features generation
DN0 = 300
X0 = np.hstack((X0,np.random.normal(0.0, 0.1, DN0 * N).reshape(N,DN0))) | _____no_output_____ | MIT | 2. Sparse SSHIBA.ipynb | alexjorguer/SSHIBA |
Once the data is generated we divide it into train and test in order to be able to test the performance of the model. After that, we can normalize the data. | from sklearn.model_selection import train_test_split
X_tr, X_tst, Y_tr, Y_tst = train_test_split(X0, X1, test_size=0.3, random_state = 31)
from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
X_tr = scaler.fit_transform(X_tr)
X_tst = scaler.transform(X_tst) | _____no_output_____ | MIT | 2. Sparse SSHIBA.ipynb | alexjorguer/SSHIBA |
Training the modelOnce the data is prepared we just have to feed it to the model. As the model has so many possibilities we have decided to pass the data to the model following a particular structure so that we can now, for each view, if the data corresponds to real, multilabel or categorical as well as knowing if we want to calculate the model with sparsity in the features.In this case we are indicating we want to prune the latent features, so that if a latent feature has a sufficiently low value for all the features in matrix $W$, this latent feature will be eliminated. | import os
os.sys.path.append('lib')
import sshiba
myKc = 20 # number of latent features
max_it = int(5*1e4) # maximum number of iterations
tol = 1e-6 # tolerance of the stopping condition (abs(1 - L[-2]/L[-1]) < tol)
prune = 1 # whether to prune the irrelevant latent features
myModel = sshiba.SSHIBA(myKc, prune)
X0_tr = myModel.struct_data(X_tr, 0, 1)
X1_tr = myModel.struct_data(Y_tr, 0, 0)
X0_tst = myModel.struct_data(X_tst, 0, 0)
X1_tst = myModel.struct_data(Y_tst, 0, 0)
myModel.fit(X0_tr, X1_tr, max_iter = max_it, tol = tol, Y_tst = X1_tst, X_tst = X0_tst, mse = 1)
print('Final MSE %.3f' %(myModel.mse[-1])) | Iteration 1620 Lower Bound 473636.1 K 9
Model correctly trained. Convergence achieved
Final L(Q): 473636.1
Final MSE 9.493
| MIT | 2. Sparse SSHIBA.ipynb | alexjorguer/SSHIBA |
Visualization of the results Lower Bound and MSENow the model is trained we can plot the evolution of the lower bound through out the iterations. This lower bound is calculated using the values of the variables the model is calculating and is the value we are maximizing. As we want to maximize this value it has to be always increasing with each iteration.At the same time, we are plotting now the evolution of the Minimum Square Error (MSE) with each update of the model. As we are not minimizing this curve, this doesn't necessarily have to be always decreasing and might need more iterations to reach a minimum. | def plot_mse(mse):
fig, ax = plt.subplots(figsize=(10, 4))
ax.plot(mse, linewidth=2, marker='s',markersize=5, label='SSHIBA', markerfacecolor='red')
ax.grid()
ax.set_xlabel('Iteration')
ax.set_ylabel('MSE')
plt.legend()
def plot_L(L):
fig, ax = plt.subplots(figsize=(10, 4))
ax.plot(L, linewidth=2, marker='s',markersize=5, markerfacecolor='red')
ax.grid()
ax.set_xlabel('Iteration')
ax.set_ylabel('L(Q)')
def plot_W(W):
plt.figure()
plt.imshow((np.abs(W)), aspect=W.shape[1]/W.shape[0])
plt.colorbar()
plt.title('W')
plt.ylabel('features')
plt.xlabel('K')
plot_L(myModel.L)
plt.title('Lower Bound')
plot_mse(myModel.mse)
plt.title('mse test')
plt.show() | _____no_output_____ | MIT | 2. Sparse SSHIBA.ipynb | alexjorguer/SSHIBA |
Sparsity in matrix WFor the sake of this example the model has not been automatically erasing a feature whenever it is considered as irrelevant and, instead of deleting it the model has just learned that these features are less important.As we now have the different weights given to each feature based on their relevance, we can now determine whether the algorithm has been capable of determining which features are relevant or not. To do so, we are going to start by showing the values of the learnt variable $\gamma$ which tole is to force sparsity in the feature space. | q = myModel.q_dist
gamma = q.gamma_mean(0)
ax1 = plt.subplot(2, 1, 1)
plt.title('Feature selection analysis')
plt.hist(gamma,100)
ax2 = plt.subplot(2, 1, 2)
plt.plot(gamma,'.')
plt.ylabel('gamma')
plt.xlabel('feature')
plt.show() | _____no_output_____ | MIT | 2. Sparse SSHIBA.ipynb | alexjorguer/SSHIBA |
As we can see, the values that we have randomly added to the original data are recognisible and can be therefore easily selected as relevant. We can also see the efect of the sparsity by looking at matrix $W$ where the features that are found to be irrelevant have lower values than the ones which are relevant. | pos_ord_var=np.argsort(gamma)[::-1]
plot_W(q.W[0]['mean'][pos_ord_var,:]) | _____no_output_____ | MIT | 2. Sparse SSHIBA.ipynb | alexjorguer/SSHIBA |
15. Calibration using matching sections In notebook 14 we showed how you can take splices or connectors within your calibration into account. To then calibrate the cable we used reference sections on both sides of the splice. If these are not available, or in other cases where you have a lack of reference sections, matching sections can be used to improve the calibration.For matching sections you need two sections of fiber than you know will be the exact same temperature. This can be, for example, in duplex cables or twisted pairs of cable. DemonstrationTo demonstrate matching sections, we'll load the same dataset that was used in previous notebooks, and modify the data to simulate a lossy splice, just as in notebook 14. | import os
from dtscalibration import read_silixa_files
import matplotlib.pyplot as plt
%matplotlib inline
filepath = os.path.join('..', '..', 'tests', 'data', 'double_ended2')
ds_ = read_silixa_files(
directory=filepath,
timezone_netcdf='UTC',
file_ext='*.xml')
ds = ds_.sel(x=slice(0, 110)) # only calibrate parts of the fiber
sections = {
'probe1Temperature': [slice(7.5, 17.)], # cold bath
'probe2Temperature': [slice(24., 34.)], # warm bath
}
ds.sections = sections | 6 files were found, each representing a single timestep
6 recorded vars were found: LAF, ST, AST, REV-ST, REV-AST, TMP
Recorded at 1693 points along the cable
The measurement is double ended
Reading the data from disk
| BSD-3-Clause | examples/notebooks/15Matching_sections.ipynb | fprice111/python-dts-calibration |
Again, we introduce a step loss in the signal strength at x = 50 m. For the forward channel, this means all data beyond 50 meters is reduced with a 'random' factor. For the backward channel, this means all data up to 50 meters is reduced with a 'random' factor. | ds['st'] = ds.st.where(ds.x < 50, ds.st*.8)
ds['ast'] = ds.ast.where(ds.x < 50, ds.ast*.82)
ds['rst'] = ds.rst.where(ds.x > 50, ds.rst*.85)
ds['rast'] = ds.rast.where(ds.x > 50, ds.rast*.81) | _____no_output_____ | BSD-3-Clause | examples/notebooks/15Matching_sections.ipynb | fprice111/python-dts-calibration |
We will first run a calibration without adding the transient attenuation location or matching sections. A big jump in the calibrated temperature is visible at x = 50. As all calibration sections are before 50 meters, the first 50 m will be calibrated correctly. | ds_a = ds.copy(deep=True)
st_var, resid = ds_a.variance_stokes(st_label='st')
ast_var, _ = ds_a.variance_stokes(st_label='ast')
rst_var, _ = ds_a.variance_stokes(st_label='rst')
rast_var, _ = ds_a.variance_stokes(st_label='rast')
ds_a.calibration_double_ended(
st_var=st_var,
ast_var=ast_var,
rst_var=rst_var,
rast_var=rast_var,
store_tmpw='tmpw',
method='wls',
solver='sparse')
ds_a.isel(time=0).tmpw.plot(label='calibrated') | _____no_output_____ | BSD-3-Clause | examples/notebooks/15Matching_sections.ipynb | fprice111/python-dts-calibration |
Now we run a calibration, adding the keyword argument '**trans_att**', and provide a list of floats containing the locations of the splices. In this case we only add a single one at x = 50 m.We will also define the matching sections of cable. The matching sections have to be provided as a list of tuples. A tuple per matching section. Each tuple has three items, the first two items are the slices of the sections that are matching. The third item is a bool and is True if the two sections have a reverse direction (as in the "J-configuration").In this example we match the two cold baths to each other.After running the calibration you will see that by adding the transient attenuation and matching sections the calibration returns the correct temperature, without the big jump.*In single-ended calibration the keyword is called '**trans_att**'.* | matching_sections = [
(slice(7.5, 17.6), slice(69, 79.1), False)
]
st_var, resid = ds.variance_stokes(st_label='st')
ast_var, _ = ds.variance_stokes(st_label='ast')
rst_var, _ = ds.variance_stokes(st_label='rst')
rast_var, _ = ds.variance_stokes(st_label='rast')
ds.calibration_double_ended(
st_var=st_var,
ast_var=ast_var,
rst_var=rst_var,
rast_var=rast_var,
trans_att=[50.],
matching_sections=matching_sections,
store_tmpw='tmpw',
method='wls',
solver='sparse')
ds_a.isel(time=0).tmpw.plot(label='normal calibration')
ds.isel(time=0).tmpw.plot(label='matching sections')
plt.legend() | /home/bart/git/python-dts-calibration/.tox/docs/lib/python3.7/site-packages/scipy/sparse/_index.py:116: SparseEfficiencyWarning: Changing the sparsity structure of a csr_matrix is expensive. lil_matrix is more efficient.
self._set_arrayXarray_sparse(i, j, x)
| BSD-3-Clause | examples/notebooks/15Matching_sections.ipynb | fprice111/python-dts-calibration |
Deep Learning Explained Module 4 - Lab - Introduction to Regularization for Deep Neural Nets This lesson will introduce you to the principles of regularization required to successfully train deep neural networks. In this lesson you will:1. Understand the need for regularization of complex machine learning models, particularly deep NNs. 2. Know how to apply constraint-based regularization using the L1 and L2 norms.3. Understand and apply the concept of data augmentation. 4. Know how to apply dropout regularization. 5. Understand and apply early stopping. 6. Understand the advantages of various regularization methods and know when how to apply them in combination. 1.0 Why do we need regularization for deep learning?Deep learning models have a great many parameters (weights) which must be fit. This situation arises from the wide and deep architectures that are required to achieve significant **model capacity** for representing complex functions. The core issue is that over-fit models will simply learn the training data and **over-fit models do not generalize**. Therefore, regularization methods are required in order to prevent over-fitting.In particular, we can point to three interrelated problems with training deep neural networks:1. Neural network models have large numbers of parameters (weights). With any finite size data set, there is likely to be a low ratio of cases per parameter or low ratio of cases to features. 2. As a result of the large numbers of parameters, neural networks are susceptible to noise in the training data. Neural networks are generally considered less robust to noise than shallow machine learning methods. 3. Presumably as a result of the model complexity, neural networks often return unexpected predictions for data cases outside the training data domain. This property has been referred to as **brittleness**. Brittleness has proven to be a serious problem in some production systems. The regularization methods presented here will limit these effects. However, there is no 'silver bullet'! Neural networks are hard to train under the best of circumstances. 1.1 Bias-variance trade-offTo better understand this trade-off let's decompose mean square error for a model as follows:$$\Delta y = E \big[ Y - \hat{f}(X) \big]$$Where, $Y = $ the label vector. $X = $ the feature matrix. $\hat{f}(x) = $ the trained model. Expanding this relation gives us:$$\Delta y = \big( E[ \hat{f}(X)] - \hat{f}(X) \big)^2 + E \big[ ( \hat{f}(X) - E[ \hat{f}(X)])^2 \big] + \sigma^2\\\Delta y = Bias^2 + Variance + Irreducible\ Error$$Regularization will reduce variance, but increase bias. Regularization parameters must be chosen to minimize $\Delta x$. In many cases, this will prove challenging. Notice that the **irreducible error** is the limit of model accuracy. Even if we had a perfect model with no bias or variance, the irreducible error is inherent in the data and problem. 1.2 Demonstration of over-parameterizationLet's try a simple example. We will construct a regression models with different numbers of parameters and therefore different model capacities. As a first step, we will create a simple single regression model of some synthetic data. The code in the cell below creates data computed from as a straight line, but with considerable Normally distributed random noise. A plot is then created of the result. Execute this code and examine the resulting plot. | %matplotlib inline
import numpy as np
import numpy.random as nr
import matplotlib.pyplot as plt
from numpy.random import normal, seed
import sklearn.linear_model as slm
from sklearn.preprocessing import scale
import sklearn.model_selection as ms
from math import sqrt
import keras
import keras.models as models
import keras.layers as layers
from keras.layers import Dropout, LeakyReLU
from keras import regularizers
from keras.layers.normalization import BatchNormalization
from tensorflow import set_random_seed
seed(34567)
x = np.arange(start = 0.0, stop = 10.0, step = 0.25)
y = np.add(x, normal(scale = 2.0, size = x.shape[0]))
plt.scatter(x,y) | _____no_output_____ | Unlicense | Module4/IntroToRegularization.ipynb | AlephEleven/Deep-Learning-Explained |
Notice that these data points fall approximately on a straight line, but with significant deviations. Next, you will compute a simple single regression model. This model has an intercept term and a single slope parameter. The code in the cell below splits the data into randomly selected training and testing subsets. Execute this code. | indx = range(len(x))
seed(9988)
indx = ms.train_test_split(indx, test_size = 20)
x_train = np.ravel(x[indx[0]])
y_train = np.ravel(y[indx[0]])
x_test = np.ravel(x[indx[1]])
y_test = np.ravel(y[indx[1]]) | _____no_output_____ | Unlicense | Module4/IntroToRegularization.ipynb | AlephEleven/Deep-Learning-Explained |
Next, we will use the linear model in `sklearn.linear_model` package to create a single regression model for these data. The code in the cell below does just this, prints the single model coefficient, and plots the result. Execute this code. | def plot_reg(x, y_score, y):
ax = plt.figure(figsize=(6, 6)).gca() # define axis
## Get the data in plot order
xy = sorted(zip(x,y_score))
x = [x for x, _ in xy]
y_score = [y for _, y in xy]
## Plot the result
plt.plot(x, y_score, c = 'red')
plt.scatter(x, y)
plt.title('Predicted line with test data')
def reg_model(x, y):
mod = slm.LinearRegression()
x_scale = scale(x) # .reshape(-1, 1)
mod.fit(x_scale, y)
print(mod.coef_)
return mod, x_scale, mod.predict(x_scale)
mod, x_scale, y_hat = reg_model(x_train.reshape(-1, 1), y_train)
plot_reg(x_scale, y_hat, y_train) | _____no_output_____ | Unlicense | Module4/IntroToRegularization.ipynb | AlephEleven/Deep-Learning-Explained |
Examine these results. Notice that the single coefficient (slope) seems reasonable, given the standardization of the training data. Visually, the fit to the training data also looks reasonable. We should also test the fit to some test data. The code in the cell does just this and returns the RMS error. execute this code. | from math import sqrt
def test_mod(x,y, mod):
x_scale = scale(x)
y_score = mod.predict(x_scale)
plot_reg(x_scale, y_score, y)
return np.std(y_score - y)
test_mod(x_test.reshape(-1, 1), y_test, mod) | _____no_output_____ | Unlicense | Module4/IntroToRegularization.ipynb | AlephEleven/Deep-Learning-Explained |
Again, these results look reasonable. The RMSE is relatively small given the significant dispersion in these data. Now, try a model with significantly higher capacity. In this case we compute new features for a 9th order polynomial model. Using this new set of features a regression model is trained and a summary displayed. | seed(2233)
x_power = np.power(x_train.reshape(-1, 1), range(1,10))
x_scale = scale(x_power)
mod_power = slm.LinearRegression()
mod_power.fit(x_scale, y_train)
y_hat_power = mod_power.predict(x_scale)
plot_reg(x_scale[:,0], y_hat_power, y_train)
print(mod_power.coef_)
print(np.std(y_hat_power - y_train)) | _____no_output_____ | Unlicense | Module4/IntroToRegularization.ipynb | AlephEleven/Deep-Learning-Explained |
Notice the following, indicating the model is quite over-fit. - There is a wide range of coefficient values across 7 orders of magnitude. This situation is in contrast to the coefficient of the single regression model which had a reasonable single digit value.- The graph of the fitted model shows highly complex behavior. In reality, this behavior indicates the model is 'learning the data'. Now, we will try to test the model with the held-back test data. The code in the cell below creates the same features and applies the `predict` method to the model using these test features. | x_test_scale = scale(x_test.reshape(-1, 1)) # Prescale to prevent numerical overflow.
x_test_power = np.power(x_test_scale, range(1,10))
x_scale_test = scale(x_test_power)
y_hat_power = mod_power.predict(x_scale_test)
plot_reg(x_scale_test[:,0], y_hat_power, y_test)
print(np.std(y_hat_power - y_test)) | _____no_output_____ | Unlicense | Module4/IntroToRegularization.ipynb | AlephEleven/Deep-Learning-Explained |
This is clearly a terrible fit! The RMSE is enormous and the curve of predicted values bears little resemblance to the test values. Indeed, this is a common problem with over-fit models that the errors grow in very rapidly toward the edges of the training data domain. We can definitely state that this model **does not generalize**. 2.0 l2 regularizationWe will now explore one of the mostly widely used regularization methods, often referred to as l2 regularization. The same method goes by some other names, as it has been 'invented' several times. In particular, this method is known as, **Tikhonov regularization**, **l2 norm regularization**, **pre-whitening** in engineering, and for linear models **ridge regression**. In all likelihood the method was first developed by the Russian mathematician Andrey Tikhonov in the late 1940's. His work was not widely known in the West since his short book on the subject, [Solution of Ill-Posed Problems](https://www.researchgate.net/publication/44438630_Solutions_of_ill-posed_problems_Andrey_N_Tikhonov_and_Vasiliy_Y_Arsenin), was only published in English in 1977, about 30 years after it had appeared in Russian. **Figure 2.1 Commemorative plaque for Andrey Nikolayevich Tikhonov at Moscow State University**So, what is the basic idea? l2 regularization applies a **penalty** proportional to the **l2** or **Euclidean norm** of the model weights to the loss function. The total loss function then becomes: $$J(W) = J_{MLE}(W) + \lambda ||W||^2$$Where,$$||W||^2 = \big( w_1^2 + w_2^2 + \ldots + w_n^2 \big)^{\frac{1}{2}} = \Big( \sum_{i=1}^n w_i^2 \Big)^{\frac{1}{2}}$$We call $||W||^2$ the l2 norm of the weights since we square the power of the weights, sum, and then take the square root, or $\frac{1}{2}$ power. You can think of this penalty as constraining the 12 or Euclidean norm of the model weight vector. The value of the hyperparameter $\lambda$ determines how much the norm of the coefficient vector constrains the solution. You can see a view of this geometric interpretation in Figure 2.2 below.  **Figure 2.2. Geometric view of l2 regularization**Notice that for a constant value of l2, the values of the model parameters $B1$ and $B2$ are related. For example, if $B1$ is maximized then $B2 \sim 0$, or vice versa. It is important to note that l2 regularization is a **soft constraint**. Coefficients are driven close to, but likely not exactly to, zero. 2.1 Regularization for regression Let's go back to the regression example. Recall that the 9th order polynomial regression model was massively over-fit. Can l2 regularization help this situation? We can create a model applying regularization and find out. The code in the cell below uses the `Ridge` model from `sklearn.linear_model`. The `Ridge` model has an argument `alpha` which corresponds to the regularization parameter, in the notation we have been using. Execute the code and examine the result. | mod_L2 = slm.Ridge(alpha = 100.0)
mod_L2.fit(x_scale, y_train)
y_hat_L2 = mod_L2.predict(x_scale)
print(np.std(y_hat_L2 - y_train))
print(mod_L2.coef_)
plot_reg(x_train, y_hat_L2, y_train) | _____no_output_____ | Unlicense | Module4/IntroToRegularization.ipynb | AlephEleven/Deep-Learning-Explained |
This model is quite different from the un-regularized one we trained previously. - The coefficients all have small values. Some of the coefficients are significantly less than 1. These small coefficients are a direct result of the l2 penalty.- The fitted curve looks rather reasonable given the noisy data.Now test the model on the test data. Execute the code in the cell below and examine the results. | y_hat_L2 = mod_L2.predict(x_scale_test)
plot_reg(x_scale_test[:,0], y_hat_L2, y_test)
print(np.std(y_hat_L2 - y_test)) | _____no_output_____ | Unlicense | Module4/IntroToRegularization.ipynb | AlephEleven/Deep-Learning-Explained |
This result looks a lot more reasonable. The RMSE is nearly the same as for the single feature regression example. Also, the predicted curve looks reasonable.In summary, we have seen that l2 regularization significantly improves the result for the 9th order polynomial regression. The coefficients are kept within a reasonable range and the predictions are much more reasonable than the unconstrained model. 2.2 l2 regularization for deep learning models So, you may well wonder, how well l2 regularization applies to neural networks? Let's give it a try using the 9th order polynomial data. The code in the cell below defines and fits the regression model with a single hidden layer with 128 units. No regularization is applied in this first model. | nr.seed(345)
set_random_seed(4455)
nn = models.Sequential()
nn.add(layers.Dense(128, activation = 'relu', input_shape = (9, )))
nn.add(layers.Dense(1))
nn.compile(optimizer = 'rmsprop', loss = 'mse', metrics = ['mae'])
history = nn.fit(x_scale, y_train,
epochs = 30, batch_size = 1,
validation_data = (x_scale_test, y_test),
verbose = 0) | _____no_output_____ | Unlicense | Module4/IntroToRegularization.ipynb | AlephEleven/Deep-Learning-Explained |
With the model fit, let's have a look at the loss function vs. training epoch. Execute the code in the cell below and examine the result. | def plot_loss(history):
train_loss = history.history['loss']
test_loss = history.history['val_loss']
x = list(range(1, len(test_loss) + 1))
plt.plot(x, test_loss, color = 'red', label = 'Test loss')
plt.plot(x, train_loss, label = 'Train loss')
plt.legend()
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.title('Loss vs. Epoch')
plot_loss(history) | _____no_output_____ | Unlicense | Module4/IntroToRegularization.ipynb | AlephEleven/Deep-Learning-Explained |
It looks like this model becomes overfit after 3 or 4 training epochs. Execute the code in the cell below to compute and plot predictions for the unconstrained model. | history = nn.fit(x_scale, y_train,
epochs = 4, batch_size = 1,
validation_data = (x_scale_test, y_test),
verbose = 0)
predicted = nn.predict(x_scale_test)
plot_reg(x_scale_test[:,0], predicted, y_test)
print(np.std(predicted - y_test)) | _____no_output_____ | Unlicense | Module4/IntroToRegularization.ipynb | AlephEleven/Deep-Learning-Explained |
Both the high RMSE and the odd behavior of the predicted curve indicates that this model does not generalize well at all. Notice in particular, how the predicted curve moves away from the test data values on the right. Now, we will try to improve this result by applying l2 norm regularization to the neural network. The code in cell below adds l2 regularization to the model. Execute the code and examine the results. | nr.seed(45678)
set_random_seed(45546)
nn = models.Sequential()
nn.add(layers.Dense(128, activation = 'relu', input_shape = (9, ),
kernel_regularizer=regularizers.l2(2.0)))
nn.add(layers.Dense(1))
nn.compile(optimizer = 'rmsprop', loss = 'mse', metrics = ['mae'])
history = nn.fit(x_scale, y_train,
epochs = 30, batch_size = 1,
validation_data = (x_scale_test, y_test),
verbose = 0)
plot_loss(history) | _____no_output_____ | Unlicense | Module4/IntroToRegularization.ipynb | AlephEleven/Deep-Learning-Explained |
This loss function is quite a bit different than for the unconstrained model. It is clear that regularization allows many more training epochs before over-fitting. But are the predictions any better? Execute the code in the cell below and find out. | history = nn.fit(x_scale, y_train,
epochs = 30, batch_size = 1,
validation_data = (x_scale_test, y_test),
verbose = 0)
predicted = nn.predict(x_scale_test)
plot_reg(x_scale_test[:,0], predicted, y_test)
print(np.std(predicted - y_test)) | _____no_output_____ | Unlicense | Module4/IntroToRegularization.ipynb | AlephEleven/Deep-Learning-Explained |
The l2 regularization has reduced the RMSE. Just as significantly, the pathological behavior of the predicted values on the right is reduced, but clearly not eliminated. The bias effect is also visible. Notice that the left part of the fitted curve is now shifted upwards. ******************Exercise 1:** You have now tried l2 regularization with one choice of regularization hyperparameter, namely the regularization parameter. Finding a good choice for the regularization parameter can require some trial and error. The objective is to find a value that produces a minimum test error.In the code cells below, create models as follows: 1. A regularization parameter of 20.0, using a `numpy.random.seed` of 9456 and `set_random_seed` for the TensorFlow backend of 555662. A regularization parameter of 200.0, using a `numpy.random.seed` of 9566 and `set_random_seed` for the TensorFlow backend of 44223. Plot the loss history for both models. Make sure you give you models different names. | nr.seed(9456)
set_random_seed(55566)
nr.seed(9566)
set_random_seed(44223)
| _____no_output_____ | Unlicense | Module4/IntroToRegularization.ipynb | AlephEleven/Deep-Learning-Explained |
Next, in the cells below you will create code to compute and plot the predicted values from your model for the test data, along with the error metric. Include the test data values on your plot. | history20 = nn20.fit(x_scale, y_train,
epochs = 30, batch_size = 1,
validation_data = (x_scale_test, y_test),
verbose = 0)
predicted20 = nn20.predict(x_scale_test)
plot_reg(x_scale_test[:,0], predicted20, y_test)
print(np.std(predicted20 - y_test))
history200 = nn200.fit(x_scale, y_train,
epochs = 30, batch_size = 1,
validation_data = (x_scale_test, y_test),
verbose = 0)
predicted200 = nn200.predict(x_scale_test)
plot_reg(x_scale_test[:,0], predicted200, y_test)
print(np.std(predicted200 - y_test)) | _____no_output_____ | Unlicense | Module4/IntroToRegularization.ipynb | AlephEleven/Deep-Learning-Explained |
Finally, compare the results for the three models with regularization hyperparameter values of 2.0, 20.0, and 200.0. Notice how the RMSE improves as the hyperparameter increases. Notice also, that the test loss for the highest hyperparameter value decreases most uniformly, indicating less over-fitting of the model. 3.0 l1 regularizationWe can also do regularization using other norms. The **l1 regularization** or **Lasso** method limits the sum of the absolute values of the model coefficients. The l1 norm is sometime know as the **Manhattan norm**, since distance are measured as if you were traveling on a rectangular grid of streets. This is in contrast to the l2 norm that measures distance 'as the crow flies'. We can compute the l1 norm of the weights as follows:$$||W||^1 = \big( |w_1| + |w_2| + \ldots + |w_n| \big) = \Big( \sum_{i=1}^n |w_i| \Big)^1$$where $|x|$ is the absolute value of $x$. Notice that to compute the l1 norm, we raise the sum of the absolute values to the first power.As with l2 regularization, in l1 regularization we use a penalty term of the l1 norm of the weights. A penalty multiplier, $\alpha$, determines how much the norm of the coefficient vector constrains values of the weights. The complete loss function then becomes: $$J(W) = J_{MLE}(W) + \alpha ||W||^1$$You can see a view of this geometric interpretation in Figure 3.1 below.  **Figure 3.1. Geometric view of L1 regularization**Notice that in Figure 3.1 if $B1 = 0$ then $B2$ has a value at the limit, or vice versa. In other words, using a l1 norm constraint forces some weight values to zero to allow other coefficients to take correct values. In this way, the l1 norm constraint **knocks out** some weights from the model altogether. In contrast to l2 regularization, l1 regularization will drive some coefficients to exactly zero. 3.1 l1 regularizationWith these ideas in mind, let's apply l1 norm regularization to the 9th order polynomial regression problem. The code in cell below applies l1 regularized or Lasso regularization to the linear regression problem. Execute this code and examine the results. | mod_L1 = slm.Lasso(alpha = 2.0, max_iter=100000)
mod_L1.fit(x_scale, y_train)
y_hat_L1 = mod_L1.predict(x_scale)
print(np.std(y_hat_L1 - y_test))
print(mod_L1.coef_)
plot_reg(x_train, y_hat_L1, y_train) | _____no_output_____ | Unlicense | Module4/IntroToRegularization.ipynb | AlephEleven/Deep-Learning-Explained |
Notice the following about the results of this l1 regularized regression:- Many of the coefficients are 0, as expected.- The fitted curve looks reasonable. Now, execute the code in the cell below and examine the prediction results. | y_hat_L1 = mod_L1.predict(x_scale_test)
plot_reg(x_scale_test[:,0], y_hat_L1, y_test)
print(np.std(y_hat_L1 - y_test)) | _____no_output_____ | Unlicense | Module4/IntroToRegularization.ipynb | AlephEleven/Deep-Learning-Explained |
The RMSE has been reduced considerably, and is less than for l2 regularization regression. The plot of predicted values looks similar to the single regression model, but with some bias. 3.2 Neural network with l1 regularization Now, we will try l1 regularization with a neural network. The code in the cell below defines, fits and plots a single layer neural network using l1 regularization. Execute this code and examine the results. | nn = models.Sequential()
nn.add(layers.Dense(128, activation = 'relu', input_shape = (9, ),
kernel_regularizer=regularizers.l1(10.0)))
nn.add(layers.Dense(1))
nn.compile(optimizer = 'rmsprop', loss = 'mse', metrics = ['mae'])
history = nn.fit(x_scale, y_train,
epochs = 100, batch_size = 1,
validation_data = (x_scale_test, y_test),
verbose = 0)
plot_loss(history) | _____no_output_____ | Unlicense | Module4/IntroToRegularization.ipynb | AlephEleven/Deep-Learning-Explained |
As a result of the l1 regularization the training loss does not exhibit signs of over-fitting for quite a few epochs. Next, excute the code in the cell below to compute and display predicted values from the trained network. | history = nn.fit(x_scale, y_train,
epochs = 40, batch_size = 1,
validation_data = (x_scale_test, y_test),
verbose = 0)
predicted = nn.predict(x_scale_test)
plot_reg(x_scale_test[:,0], predicted, y_test)
print(np.std(predicted - y_test)) | _____no_output_____ | Unlicense | Module4/IntroToRegularization.ipynb | AlephEleven/Deep-Learning-Explained |
These results are a definite improvement. The RMSE is similar to that produced by the l2 regularization neural network. Further, the fitting curve shows similar behavior and bias. This bias is the result of the regularization. 4.0 Early stoppingEarly stopping is conceptually simple. Early stopping terminates the training of the neural network model at an epoch before it becomes terribly over-fit. That's it! That is the idea of early stopping.In fact, we have already been using early stopping as we create and test the foregoing regularized models. The question here is, how do we automate this process? 4.1 Early stopping algorithmThe early stopping algorithm simple. This pseudo code shows the basic loop for early stopping on first epoch with a lower performance metric, which is executed after the first training epoch of the model. `Do while TRUE: store current model parameters update model for epoch if(performance_for_epoch < stored_performance_metric) return stored_model else stored_performance_metric = performance_for_epoch store_model = model ` 4.2 How does early stopping work?Early stopping terminates model learning before over-fitting occurs. But how can we interpret this action in terms of the loss function $J(W)_{MLE}$? Figure 4.1 below provides some insight.  **Figure 4.1 Effect of early stopping on $J(W)_{MLE}$**On the left side of the diagram you can see contours of the weight norm. On the right are contours Early stopping terminates training at some model weight norm $||W||^2$. Ideally this is at the point where the training of $J(W)_{MLE}$ starts to over-fit. Thus, we can think of early stopping as analogous to l2 norm regularization where we write the loss function as:$$argmin_W J(W) = J(W)_{MLE} + \alpha ||W||^2$$where,$\alpha = $ a regularization parameter controlling the stopping point. 4.3 Early stopping exampleManually applying early stopping is both computationally inefficient and rather tedious. Fortunately, Keras has a build in capability that allows automation. To implement this early stopping we need to define 2 Keras **callbacks**. Two such callbacks are required:1. The first callback, **EarlyStopping**, is for the early stopping method.2. The second call back **checkpoints** or saves the current model. These callbacks are defined in the form of a **callbacks list**. Notice that the model defined includes l2 regularization. Thus, this model should replicate the performance observed with manual early stopping. To see how this works, examine and then execute the code in the following cell. | ## First define and compile a model.
nn = models.Sequential()
nn.add(layers.Dense(128, activation = 'relu', input_shape = (9, ),
kernel_regularizer=regularizers.l2(1.0)))
nn.add(layers.Dense(1))
nn.compile(optimizer = 'RMSprop', loss = 'mse', metrics = ['mae'])
## Define the callback list
filepath = 'my_model_file.hdf5' # define where the model is saved
callbacks_list = [
keras.callbacks.EarlyStopping(
monitor = 'val_loss', # Use loss to monitor the model
patience = 1 # Stop after one step with lower accuracy
),
keras.callbacks.ModelCheckpoint(
filepath = filepath, # file where the checkpoint is saved
monitor = 'val_loss', # Don't overwrite the saved model unless val_loss is worse
save_best_only = True # Only save model if it is the best
)
]
## Now fit the model
nr.seed(5566)
set_random_seed(6767)
history = nn.fit(x_scale, y_train,
epochs = 40, batch_size = 1,
validation_data = (x_scale_test, y_test),
callbacks = callbacks_list, # Call backs argument here
verbose = 0)
## Visualize the outcome
plot_loss(history) | _____no_output_____ | Unlicense | Module4/IntroToRegularization.ipynb | AlephEleven/Deep-Learning-Explained |
You can see the behavior of the loss with training epoch is behaving as with l2 regularization alone. Notice that the training has been automatically terminated at the point the loss function is at its optimum. Let's also have a look at the accuracy vs. epoch. Execute the code in the cell below and examine the result. | def plot_accuracy(history):
train_acc = history.history['mean_absolute_error']
test_acc = history.history['val_mean_absolute_error']
x = list(range(1, len(test_acc) + 1))
plt.plot(x, test_acc, color = 'red', label = 'Test error rate')
plt.plot(x, train_acc, label = 'Train error rate')
plt.legend()
plt.xlabel('Epoch')
plt.ylabel('Error rate')
plt.title('Error Rate vs. Epoch')
plot_accuracy(history) | _____no_output_____ | Unlicense | Module4/IntroToRegularization.ipynb | AlephEleven/Deep-Learning-Explained |
The curve of test accuracy is consistent with the test loss.The code in the cell below retrieves the best model (by our stopping criteria) from storage, computes predictions and displays the result. Execute this code and examine the results. | best_model = keras.models.load_model(filepath)
predictions = best_model.predict(x_scale_test)
plot_reg(x_scale_test[:,0], predictions, y_test)
print(np.std(predictions - y_test)) | _____no_output_____ | Unlicense | Module4/IntroToRegularization.ipynb | AlephEleven/Deep-Learning-Explained |
As expected, these results are similar, but a bit worse, than those obtained while manually stopping the training of the l2 regularized neural network. 5.0 Dropout regularizationAll of the regularization methods we have discussed so far, originated long before the current deep neural network era. We will now look at the **dropout regularization** method. Of all widely used regularization methods, dropout is one of the few specifically developed for neural networks. The seminal paper, [Dropout: A Simple Way to Prevent Neural Networks fromOverfitting by Srivastava et. al](http://www.cs.toronto.edu/~rsalakhu/papers/srivastava14a.pdf), 2014, is quite readable and provides a lot more detail than is presented here.We have already seen how l1 norm regularization knocks out some model weights. The dropout method regularizes neural networks by creating an **ensemble** of networks with some fraction $p \lt 1.0$ of the hidden units removed. Ensemble methods are know to be strong regularizers and produce superior results by combining the learning of multiple **weak learners**. The dropout method is somewhat different from other ensemble methods, such as bagging. This reweighting scheme has several advantages:- The model weights for the resulting networks are reweighted by the probabilities that they are sampled in the ensemble. - The memory required to train the model is simply $O(n)$, where n is the number of weights. A bagged model requires $O(M*n)$, where $M$ is the number of models in the ensemble.- When making predictions in production only one model is used. Whereas, the predictions for each model in the bag must be computed for bagging. To understand this method, let's recall the basic model for the output of a lth layer in a fully connected network:$$z^{(l+1)}_i = w^{(l+1)}_i \cdot h^{(l)} + b^{(l+1)}_i\\h^{(l+1)}_i = \sigma(z^{(l+1)}_i)$$where:$\sigma = $ the activation function. Now, we need to sample the hidden units with probability $p$, in which case we can write:$$r^{(l)}_i \sim Bernoulli(p)\\\tilde{h}^{(l)}_i = r^{(l)}_i * y^{(l)}\\z^{(l+1)}_i = w^{(l+1)}_i \cdot \tilde{h}^{(l)}_i + b^{(l+1)}_i\\h^{(l+1)}_i = \sigma(z^{(l+1)}_i)$$where:$r^{(l)}_i =$dropout vector with values $\{0,1\}$.To get a feel for what this means in practice examine Figure 5.1. This figure shows a fully connected network with 4 hidden units and a dropout probability $p = 0.5$. **Figure 5.1 Possible dropouts for a simple fully connected network with p = 0.5**Examine Figure 5.1 and notice the following:- There are 6 ways to achieve dropout with exactly 1/2 the units as shown. - No units might dropout with probability $p^4$. - A single unit might drop out with probability $p^3 (1-p)$. - All units might drop out with probability $(1-p)^4$. This case is not admissible so should not be sampled. In fact there are $n^2$ possible dropout patterns for a hidden layer with n units. This scaling quickly leads to a problem. For any realistic size network, it is not possible to fully sample all of the possibilities. Instead, we need to use some kind of approximation with a reasonable number of samples. Ideally, we want a model that gives us the posterior probability of $y$, the output, given $x$ the input which we can write $p(y\ |\ x)$. If we had infinite computing resources we could Monte Carlo sample this distribution for our neural network. This ideal reference neural network is known as **Bayesian network**. Clearly, for large scale networks it is not possible to compute this result. We have to settle for a sampled result. We reweight by the probability that a sample is created. Continuing with the notation we used before we can write:$$p(y\ |\ x) \sim \sum_r p(r) p(y\ |\ x, r)$$where,$r = $ the Bernoulli sampled mask vector. Given enough samples the approximation above will converge to the desired probability distribution. However, in practice it has been found that the **geometric mean** of the ensemble converges faster. 5.1 Computing a neural network with dropout regularizationWith a bit of theory in mind, we will now apply dropout regularization to training a neural network. The code in the cell below defines a neural network with a dropout layer with $p =0.5$. The rest of this network is identical to other networks we have been working with. Execute this code and examine the result. | ## First define and compile a model with a dropout layer.
nn = models.Sequential()
nn.add(layers.Dense(128, activation = 'relu', input_shape = (9, )))
nn.add(Dropout(rate = 0.5)) # Use 50% dropout on this model
nn.add(layers.Dense(1))
nn.compile(optimizer = 'rmsprop', loss = 'mse', metrics = ['mae'])
## Now fit the model
nr.seed(1144)
set_random_seed(6723)
history = nn.fit(x_scale, y_train,
epochs = 40, batch_size = 1,
validation_data = (x_scale_test, y_test),
callbacks = callbacks_list, # Call backs argument here
verbose = 0)
## Visualize the outcome
plot_loss(history) | _____no_output_____ | Unlicense | Module4/IntroToRegularization.ipynb | AlephEleven/Deep-Learning-Explained |
The familiar loss plot looks a bit different here. Notice the kinks in the training loss curve. This is likely a result of the dropout sampling. Execute the code in the cell below, and examine the accuracy vs. epoch curves. | plot_accuracy(history) | _____no_output_____ | Unlicense | Module4/IntroToRegularization.ipynb | AlephEleven/Deep-Learning-Explained |
The behavior of the training accuracy curve has a similar appearance to the loss curve in terms of the jagged appearance. Execute the code in the cell below examine the prediction results for this model. | best_model = keras.models.load_model(filepath)
predictions = best_model.predict(x_scale_test)
plot_reg(x_scale_test[:,0], predictions, y_test)
print(np.std(predictions - y_test)) | _____no_output_____ | Unlicense | Module4/IntroToRegularization.ipynb | AlephEleven/Deep-Learning-Explained |
These results appear similar to those obtained with other regularization methods for neural networks on this problem, particularly, early stopping. While the dropout method is an effective regularizer it is no 'silver bullet'. 6.0 Batch NormalizationIt is often the case that the distribution of output values of some hidden layers changes . The result is that propagated gradients can become near zero, significantly slowing convergence in many cases. We will discuss this **vanishing gradient problem** in another lesson. In 2015, [Sergey and Szegedy](https://arxiv.org/pdf/1502.03167.pdf) introduced a solution to this problem with their paper **Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift**. The basic idea is simple. A batch normalization layer maintains an exponential moving average estimate of the mean and variance of the outputs of layer. These values are used to normalize the output values of that layer. In other words, the batch normalization layer ensures the distribution of the output values are constant. Let's try an example. The simple neural network model defined in the code cell below includes a batch normalization layer. Also notice that to improve convergence the early stopping has been modified to have a patience of 3. Execute this code. | ## Use patience of 3
callbacks_list = [
keras.callbacks.EarlyStopping(
monitor = 'val_loss', # Use loss to monitor the model
patience = 3 # Stop after three steps with lower accuracy
),
keras.callbacks.ModelCheckpoint(
filepath = filepath, # file where the checkpoint is saved
monitor = 'val_loss', # Don't overwrite the saved model unless val_loss is worse
save_best_only = True # Only save model if it is the best
)
]
## Now, define an NN model using batch normalization.
## First define and compile a model with a batch normalization layer.
nn = models.Sequential()
nn.add(layers.Dense(128, input_shape = (9, ), activation = 'relu'))
nn.add(BatchNormalization(momentum = 0.99))
nn.add(layers.Dense(1))
## Define the optimizer and compile
optm = keras.optimizers.rmsprop(lr=1.0)
nn.compile(optimizer = optm, loss = 'mse', metrics = ['mae'])
## Now fit the model
nr.seed(345)
set_random_seed(4532)
history = nn.fit(x_scale, y_train,
epochs = 100, batch_size = 1,
validation_data = (x_scale_test, y_test),
callbacks = callbacks_list, # Call backs argument here
verbose = 0)
## Visualize the outcome
plot_loss(history) | _____no_output_____ | Unlicense | Module4/IntroToRegularization.ipynb | AlephEleven/Deep-Learning-Explained |
The loss decreases rapidly and then remains in a narrow range thereafter. It appears that convergence is quite rapid.How does the accuracy evolve with the training episodes? Execute the code in the cell below to display the result. | plot_accuracy(history) | _____no_output_____ | Unlicense | Module4/IntroToRegularization.ipynb | AlephEleven/Deep-Learning-Explained |
This accuracy curve is rather unusual. It seems to reflect the simple regularization being used. Finally, execute the code in the cell below to evaluate the predictions made with this model. | best_model = keras.models.load_model(filepath)
predictions = best_model.predict(x_scale_test)
plot_reg(x_scale_test[:,0], predictions, y_test)
print(np.std(predictions - y_test)) | _____no_output_____ | Unlicense | Module4/IntroToRegularization.ipynb | AlephEleven/Deep-Learning-Explained |
The fit to the test data look fairly good. 7.0 Using multiple regularization methods**Exercise 2:** In many cases more than one regularization method is applied. We have already applied early stopping with other regularization methods. In this exercise you will create a neural network work using four regularization methods at once:- l2 regularization- l1 regularization- Dropout- Early stopping In the cell below create code for a neural network using the above regularization methods. Your code should include the following:1. Set a `numpy.random` seed of 242244 and a `set_random_seed` for the TensorFlow backend of 4356.2. Define a call back list with `EarlyStopping` with monitor set to `val_loss` and patience set to 4, and the `ModelCheckpoint` with monitor set to `val_loss`3. A fully connected layer with 128 units and ReLU activation. Include l1 and l2 regulaization using the `l1_l2` function with the regularization parameter set to 50.0.4. A dropout layer with regularization parameter set to 0.5.5. Fit your model for 120 epochs, with batch size of 10, using the already defined callback listFit you neural network model, saving the results to a history object. | nr.seed(242244)
set_random_seed(4346)
| _____no_output_____ | Unlicense | Module4/IntroToRegularization.ipynb | AlephEleven/Deep-Learning-Explained |
In the cell below create and execute the code to plot the loss history for both training and test. | ## Visualize the outcome
plot_loss(history) | _____no_output_____ | Unlicense | Module4/IntroToRegularization.ipynb | AlephEleven/Deep-Learning-Explained |
In the cell below create and execute the code to plot the accuracy history for both training and test. | plot_accuracy(history) | _____no_output_____ | Unlicense | Module4/IntroToRegularization.ipynb | AlephEleven/Deep-Learning-Explained |
Next, in the cells below you will create code to compute and plot the predicted values from your model for the test data, along with the error metric. Include the test data values on your plot. | best_model = keras.models.load_model(filepath)
predictions = best_model.predict(x_scale_test)
plot_reg(x_scale_test[:,0], predictions, y_test)
print(np.std(predictions - y_test)) | _____no_output_____ | Unlicense | Module4/IntroToRegularization.ipynb | AlephEleven/Deep-Learning-Explained |
Multi-Layer Perceptron, MNIST---In this notebook, we will train an MLP to classify images from the [MNIST database](http://yann.lecun.com/exdb/mnist/) hand-written digit database.The process will be broken down into the following steps:>1. Load and visualize the data2. Define a neural network3. Train the model4. Evaluate the performance of our trained model on a test dataset!Before we begin, we have to import the necessary libraries for working with data and PyTorch. | # import libraries
import torch
import numpy as np | _____no_output_____ | MIT | convolutional-neural-networks/mnist-mlp/mnist_mlp_exercise.ipynb | mwizasimbeye11/udacity-pytorch-scholar-challenge |
--- Load and Visualize the [Data](http://pytorch.org/docs/stable/torchvision/datasets.html)Downloading may take a few moments, and you should see your progress as the data is loading. You may also choose to change the `batch_size` if you want to load more data at a time.This cell will create DataLoaders for each of our datasets. | from torchvision import datasets
import torchvision.transforms as transforms
# number of subprocesses to use for data loading
num_workers = 0
# how many samples per batch to load
batch_size = 20
# convert data to torch.FloatTensor
transform = transforms.ToTensor()
# choose the training and test datasets
train_data = datasets.MNIST(root='data', train=True,
download=True, transform=transform)
test_data = datasets.MNIST(root='data', train=False,
download=True, transform=transform)
# prepare data loaders
train_loader = torch.utils.data.DataLoader(train_data, batch_size=batch_size,
num_workers=num_workers)
test_loader = torch.utils.data.DataLoader(test_data, batch_size=batch_size,
num_workers=num_workers) | Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz
Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz
Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz
Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz
Processing...
Done!
| MIT | convolutional-neural-networks/mnist-mlp/mnist_mlp_exercise.ipynb | mwizasimbeye11/udacity-pytorch-scholar-challenge |
Visualize a Batch of Training DataThe first step in a classification task is to take a look at the data, make sure it is loaded in correctly, then make any initial observations about patterns in that data. | import matplotlib.pyplot as plt
%matplotlib inline
# obtain one batch of training images
dataiter = iter(train_loader)
images, labels = dataiter.next()
images = images.numpy()
# plot the images in the batch, along with the corresponding labels
fig = plt.figure(figsize=(25, 4))
for idx in np.arange(20):
ax = fig.add_subplot(2, 20/2, idx+1, xticks=[], yticks=[])
ax.imshow(np.squeeze(images[idx]), cmap='gray')
# print out the correct label for each image
# .item() gets the value contained in a Tensor
ax.set_title(str(labels[idx].item())) | _____no_output_____ | MIT | convolutional-neural-networks/mnist-mlp/mnist_mlp_exercise.ipynb | mwizasimbeye11/udacity-pytorch-scholar-challenge |
View an Image in More Detail | img = np.squeeze(images[1])
fig = plt.figure(figsize = (12,12))
ax = fig.add_subplot(111)
ax.imshow(img, cmap='gray')
width, height = img.shape
thresh = img.max()/2.5
for x in range(width):
for y in range(height):
val = round(img[x][y],2) if img[x][y] !=0 else 0
ax.annotate(str(val), xy=(y,x),
horizontalalignment='center',
verticalalignment='center',
color='white' if img[x][y]<thresh else 'black') | _____no_output_____ | MIT | convolutional-neural-networks/mnist-mlp/mnist_mlp_exercise.ipynb | mwizasimbeye11/udacity-pytorch-scholar-challenge |
--- Define the Network [Architecture](http://pytorch.org/docs/stable/nn.html)The architecture will be responsible for seeing as input a 784-dim Tensor of pixel values for each image, and producing a Tensor of length 10 (our number of classes) that indicates the class scores for an input image. This particular example uses two hidden layers and dropout to avoid overfitting. | import torch.nn as nn
import torch.nn.functional as F
## TODO: Define the NN architecture
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
# linear layer (784 -> 1 hidden node)
self.fc1 = nn.Linear(28 * 28, 512)
self.fc2 = nn.Linear(512, 256)
self.fc3 = nn.Linear(256, 10)
self.dropout = nn.Dropout(p=0.2)
def forward(self, x):
# flatten image input
x = x.view(-1, 28 * 28)
# add hidden layer, with relu activation function
x = F.relu(self.fc1(x))
x = F.relu(self.fc2(x))
x = self.fc3(x)
return x
# initialize the NN
model = Net()
print(model) | Net(
(fc1): Linear(in_features=784, out_features=512, bias=True)
(fc2): Linear(in_features=512, out_features=256, bias=True)
(fc3): Linear(in_features=256, out_features=10, bias=True)
(dropout): Dropout(p=0.2)
)
| MIT | convolutional-neural-networks/mnist-mlp/mnist_mlp_exercise.ipynb | mwizasimbeye11/udacity-pytorch-scholar-challenge |
Specify [Loss Function](http://pytorch.org/docs/stable/nn.htmlloss-functions) and [Optimizer](http://pytorch.org/docs/stable/optim.html)It's recommended that you use cross-entropy loss for classification. If you look at the documentation (linked above), you can see that PyTorch's cross entropy function applies a softmax funtion to the output layer *and* then calculates the log loss. | ## TODO: Specify loss and optimization functions
# specify loss function
criterion = nn.CrossEntropyLoss()
# specify optimizer
optimizer = torch.optim.SGD(model.parameters(), lr=0.02) | _____no_output_____ | MIT | convolutional-neural-networks/mnist-mlp/mnist_mlp_exercise.ipynb | mwizasimbeye11/udacity-pytorch-scholar-challenge |
--- Train the NetworkThe steps for training/learning from a batch of data are described in the comments below:1. Clear the gradients of all optimized variables2. Forward pass: compute predicted outputs by passing inputs to the model3. Calculate the loss4. Backward pass: compute gradient of the loss with respect to model parameters5. Perform a single optimization step (parameter update)6. Update average training lossThe following loop trains for 30 epochs; feel free to change this number. For now, we suggest somewhere between 20-50 epochs. As you train, take a look at how the values for the training loss decrease over time. We want it to decrease while also avoiding overfitting the training data. | # number of epochs to train the model
n_epochs = 30 # suggest training between 20-50 epochs
model.train() # prep model for training
for epoch in range(n_epochs):
# monitor training loss
train_loss = 0.0
###################
# train the model #
###################
for data, target in train_loader:
# clear the gradients of all optimized variables
optimizer.zero_grad()
# forward pass: compute predicted outputs by passing inputs to the model
output = model(data)
# calculate the loss
loss = criterion(output, target)
# backward pass: compute gradient of the loss with respect to model parameters
loss.backward()
# perform a single optimization step (parameter update)
optimizer.step()
# update running training loss
train_loss += loss.item()*data.size(0)
# print training statistics
# calculate average loss over an epoch
train_loss = train_loss/len(train_loader.dataset)
print('Epoch: {} \tTraining Loss: {:.6f}'.format(
epoch+1,
train_loss
)) | Epoch: 1 Training Loss: 0.556918
Epoch: 2 Training Loss: 0.222661
Epoch: 3 Training Loss: 0.156637
Epoch: 4 Training Loss: 0.119404
Epoch: 5 Training Loss: 0.095555
Epoch: 6 Training Loss: 0.078523
Epoch: 7 Training Loss: 0.065621
Epoch: 8 Training Loss: 0.055467
Epoch: 9 Training Loss: 0.047212
Epoch: 10 Training Loss: 0.040336
Epoch: 11 Training Loss: 0.034449
Epoch: 12 Training Loss: 0.029373
Epoch: 13 Training Loss: 0.025010
Epoch: 14 Training Loss: 0.021287
Epoch: 15 Training Loss: 0.018142
Epoch: 16 Training Loss: 0.015500
Epoch: 17 Training Loss: 0.013296
Epoch: 18 Training Loss: 0.011448
Epoch: 19 Training Loss: 0.009876
Epoch: 20 Training Loss: 0.008596
Epoch: 21 Training Loss: 0.007462
Epoch: 22 Training Loss: 0.006518
Epoch: 23 Training Loss: 0.005701
Epoch: 24 Training Loss: 0.005015
Epoch: 25 Training Loss: 0.004452
Epoch: 26 Training Loss: 0.003980
Epoch: 27 Training Loss: 0.003578
Epoch: 28 Training Loss: 0.003236
Epoch: 29 Training Loss: 0.002941
Epoch: 30 Training Loss: 0.002686
| MIT | convolutional-neural-networks/mnist-mlp/mnist_mlp_exercise.ipynb | mwizasimbeye11/udacity-pytorch-scholar-challenge |
--- Test the Trained NetworkFinally, we test our best model on previously unseen **test data** and evaluate it's performance. Testing on unseen data is a good way to check that our model generalizes well. It may also be useful to be granular in this analysis and take a look at how this model performs on each class as well as looking at its overall loss and accuracy. `model.eval()``model.eval(`) will set all the layers in your model to evaluation mode. This affects layers like dropout layers that turn "off" nodes during training with some probability, but should allow every node to be "on" for evaluation! | # initialize lists to monitor test loss and accuracy
test_loss = 0.0
class_correct = list(0. for i in range(10))
class_total = list(0. for i in range(10))
model.eval() # prep model for *evaluation*
for data, target in test_loader:
# forward pass: compute predicted outputs by passing inputs to the model
output = model(data)
# calculate the loss
loss = criterion(output, target)
# update test loss
test_loss += loss.item()*data.size(0)
# convert output probabilities to predicted class
_, pred = torch.max(output, 1)
# compare predictions to true label
correct = np.squeeze(pred.eq(target.data.view_as(pred)))
# calculate test accuracy for each object class
for i in range(batch_size):
label = target.data[i]
class_correct[label] += correct[i].item()
class_total[label] += 1
# calculate and print avg test loss
test_loss = test_loss/len(test_loader.dataset)
print('Test Loss: {:.6f}\n'.format(test_loss))
for i in range(10):
if class_total[i] > 0:
print('Test Accuracy of %5s: %2d%% (%2d/%2d)' % (
str(i), 100 * class_correct[i] / class_total[i],
np.sum(class_correct[i]), np.sum(class_total[i])))
else:
print('Test Accuracy of %5s: N/A (no training examples)' % (classes[i]))
print('\nTest Accuracy (Overall): %2d%% (%2d/%2d)' % (
100. * np.sum(class_correct) / np.sum(class_total),
np.sum(class_correct), np.sum(class_total))) | Test Loss: 0.070234
Test Accuracy of 0: 98% (970/980)
Test Accuracy of 1: 99% (1127/1135)
Test Accuracy of 2: 97% (1011/1032)
Test Accuracy of 3: 97% (986/1010)
Test Accuracy of 4: 98% (968/982)
Test Accuracy of 5: 98% (875/892)
Test Accuracy of 6: 98% (941/958)
Test Accuracy of 7: 97% (1003/1028)
Test Accuracy of 8: 96% (943/974)
Test Accuracy of 9: 97% (987/1009)
Test Accuracy (Overall): 98% (9811/10000)
| MIT | convolutional-neural-networks/mnist-mlp/mnist_mlp_exercise.ipynb | mwizasimbeye11/udacity-pytorch-scholar-challenge |
Visualize Sample Test ResultsThis cell displays test images and their labels in this format: `predicted (ground-truth)`. The text will be green for accurately classified examples and red for incorrect predictions. | # obtain one batch of test images
dataiter = iter(test_loader)
images, labels = dataiter.next()
# get sample outputs
output = model(images)
# convert output probabilities to predicted class
_, preds = torch.max(output, 1)
# prep images for display
images = images.numpy()
# plot the images in the batch, along with predicted and true labels
fig = plt.figure(figsize=(25, 4))
for idx in np.arange(20):
ax = fig.add_subplot(2, 20/2, idx+1, xticks=[], yticks=[])
ax.imshow(np.squeeze(images[idx]), cmap='gray')
ax.set_title("{} ({})".format(str(preds[idx].item()), str(labels[idx].item())),
color=("green" if preds[idx]==labels[idx] else "red")) | _____no_output_____ | MIT | convolutional-neural-networks/mnist-mlp/mnist_mlp_exercise.ipynb | mwizasimbeye11/udacity-pytorch-scholar-challenge |
Workshop 4 File Input and Output (I/O)**Submit this notebook to bCourses (ipynb and pdf) to receive a grade for this Workshop.**Please complete workshop activities in code cells in this iPython notebook. The activities titled **Practice** are purely for you to explore Python. Some of them may have some code written, and you should try to modify it in different ways to understand how it works. Although no particular output is expected at submission time, it is _highly_ recommended that you read and work through the practice activities before or alongside the exercises. However, the activities titled **Exercise** have specific tasks and specific outputs expected. Include comments in your code when necessary. The workshop should be submitted on bCourses under the Assignments tab.**The homework should be submitted on bCourses under the Assignments tab (both the .ipynb and .pdf files). Please label it by your student ID number (SIS ID)**[Exercises start here](exercises) In this notebook, we're going to explore some ways that we can store data in files, and extract data from files. Let's just get all of the importing out of the way: | %matplotlib inline
import numpy as np
import matplotlib as mpl
import matplotlib.pyplot as plt | _____no_output_____ | BSD-3-Clause | Week05/WS04/Workshop04.ipynb | ds-connectors/Physics-88-Fa21 |
Practice: Basic Writing and Reading ASCII Files Think of ASCII files as text files. You can open them using a text editor (like vim or emacs in Unix, or Notepad in Windows) and read the information they contain directly. There are a few ways to produce these files, and to read them once they've been produced. In Python, the simplest way is to use file objects. Let's give it a try. We create an abstract file object by calling the function `open( filename, access_mode )` and assigning its return value to a variable (usually `f`). The argument `filename` just specifices the name of the file we're interested in, and `access_mode` tells Python what we plan to do with that file: 'r': read the file 'w': write to the file (creates a new file, or clears an existing file) 'a': append the file Note that both arguments should be strings.For full syntax and special arguments, see documentation at https://docs.python.org/2/library/functions.htmlopen | f = open( 'welcome.txt', 'w' ) | _____no_output_____ | BSD-3-Clause | Week05/WS04/Workshop04.ipynb | ds-connectors/Physics-88-Fa21 |
**A note of caution**: as soon as you call `open()`, Python creates a new file with the name you pass to it if you open it in write mode (`'w'`). Python will overwrite existing files if you open a file of the same name in write ('`w`') mode. Now we can write to the file using `f.write( thing_to_write )`. We can write anything we want, but it must be formatted as a string. | topics = ['Data types', 'Loops', 'Functions', 'Arrays', 'Plotting', 'Statistics']
f.write( 'Welcome to Physics 77, Fall 2021\n' ) # the newline command \n tells Python to start a new line
f.write( 'Topics we will learn about include:\n' )
for top in topics:
f.write( top + '\n')
f.close() # don't forget this part! | _____no_output_____ | BSD-3-Clause | Week05/WS04/Workshop04.ipynb | ds-connectors/Physics-88-Fa21 |
**Practice 1:** Use the syntax you have just learned to create an ASCII file titled "`sine.txt`" with two columns containing 20 x and 20 y values. The x values should range from $0$ to $2\pi$ - you can use `np.linspace()` to generate these values (as many as you want). The y values should be $y = sin(x)$ (you can use `np.sin()`) for this. Then, use a `for` loop as above to write a new line for each pair of x and y values. To make sure that each x,y pair is on a new line, remember to add `\n` to the end of each line like above. To separate the values by a tab so that the columns are nicely aligned, you can use the "character" `\t`. So `\n` inserts a new line and `\t` inserts a tab. You may wish to use some kind of string formatting to decimals from running too far. Here is an example with just one data point: x = 0.5 * np.pi y = np.sin(x) print("%.5f \t %.5f" % (x,y))Pay close attention to the fact that when you use the `write` function, the argument that you pass to it needs to be a string. | # Code for Practice 1 | _____no_output_____ | BSD-3-Clause | Week05/WS04/Workshop04.ipynb | ds-connectors/Physics-88-Fa21 |
Now we will show how to *read* the values from `welcome.txt` back out: | f = open( 'welcome.txt', 'r' )
for line in f:
print(line.strip())
f.close() | _____no_output_____ | BSD-3-Clause | Week05/WS04/Workshop04.ipynb | ds-connectors/Physics-88-Fa21 |
**Practice 2:** In the cell immediately above, you see that we print `line.strip()` instead of just printing `line`. Remove the `.strip()` part and see what happens. Suppose we wanted to skip the first two lines of `welcome.txt` and print only the list of topics `('Data types', 'Loops', 'Functions', 'Arrays', 'Plotting', 'Statistics')`. We can use `readline()` to "read" the first two lines but not store their value, thereby ignoring them. | f = open( 'welcome.txt', 'r' )
f.readline()
f.readline() # skip the first two lines
topicList = []
for line in f:
topicList.append(line.strip())
f.close()
print(topicList) | _____no_output_____ | BSD-3-Clause | Week05/WS04/Workshop04.ipynb | ds-connectors/Physics-88-Fa21 |
Python reads in spacing commands from files as well as strings. The `.strip()` just tells Python to ignore those spacing commands. What happens if you remove it from the code above? **Practice 3:** Use the syntax you have just learned to read back each line of x and y values from the `sine.txt` file that you just wrote in Practice 1. Don't worry about breaking up the lines into individual values quite yet. | # Code for Practice 3 | _____no_output_____ | BSD-3-Clause | Week05/WS04/Workshop04.ipynb | ds-connectors/Physics-88-Fa21 |
Practice Reading in Numerical Data as Floats Numerical data can be somewhat trickier to read in than strings. In the practices above, you read in `sine.txt` but each line was a `string` not a pair of `float` values. Let's read in a file I produced in another program, that contains results from a BaBar experiment, where we searched for a "dark photon" produced in e+e- collisions. The data are presented in two columns: mass chargeEvery time we read in a new line, it is going to start out being a `string`. To convert a line like 1.57079 1.00000 into a pair of values we need to do two things. The first is we need to split that string into two pieces. Fortunately, there is a function to do that for us. Suppose that we read in a `line` and we want to split it. We can do it as follows: line.split()For the line above, calling `.split()` would return the following `list`: ['1.57079','1.00000'] From there, we need to convert each value in the list into a `float` and store those values somewhere. This can be done using the `float()` function: x_values = [] y_values = [] split_values = ['1.57079','1.00000'] x_values.append(float(split_values[0])) y_values.append(float(split_values[1]))Now `x_values` is a `list` containing 1 element which is the `float` value `1.57079` and `y_values` is a `list` containing 1 element which is the `float` value `1.00000`. | # Example using BaBar_2016.dat
f = open('BaBar_2016.dat', 'r')
# read each line, split the data wherever there's a blank space,
# and convert the values to floats
# lists where we will store the values we read in
mass = []
charge = []
for line in f:
tokens = line.split()
mass.append(float(tokens[0]))
charge.append(float(tokens[1]))
f.close() | _____no_output_____ | BSD-3-Clause | Week05/WS04/Workshop04.ipynb | ds-connectors/Physics-88-Fa21 |
We got it; let's plot it! | import matplotlib.pyplot as plt
%matplotlib inline
plt.plot(mass, charge, 'r-' )
plt.xlim(0, 8)
plt.ylim(0, 2e-3)
plt.xlabel('mass (GeV)')
plt.ylabel('charge, 90% C.L. limit')
plt.show() | _____no_output_____ | BSD-3-Clause | Week05/WS04/Workshop04.ipynb | ds-connectors/Physics-88-Fa21 |
**Practice 4:** Use the syntax you have just learned to read back each line of x and y values from the sine.txt file that you wrote in Practice 1, and split each line into `float` values and store them. Then, plot your stored x and y values to make sure you have done everything correctly | # Code for Practice 4 | _____no_output_____ | BSD-3-Clause | Week05/WS04/Workshop04.ipynb | ds-connectors/Physics-88-Fa21 |
Of course, you already know of another way to read in values like this: `numpy.loadtxt()` and `numpy.genfromtxt()`. If you have already been using those, feel free to move on. Otherwise, take a moment to make yourself aware of these functions as they will massively simplify your life. Fortunately, Python's `numpy` library has functions for converting file information into numpy arrays, which can be easily analyzed and plotted. The above can be accomplished with a lot less code (and a lot less head scratching!) The `genfromtxt` function takes as it's argument the name of the file you want to load, and any optional arguments you want to add to help with the loading and formatting process. Some of the most useful optional arguments are: **dtype**: data type of the resulting array **comments**: the character that indicates the start of a comment (e.g. '') lines following these characters will be ignored, and not read into the array **delimiter**: the character used to separate values. Often, it's whitespace, but it could also be ',', '|', or others **skip_header**: how many lines to skip at the beginning of the file **skip_footer**: how many lines to skip at the end of the file **use_cols**: which columns to load and which to ignore **unpack**: If True (the default is False), the array is transposed (i.e., you can a set of columns, not a set of rows.) You can accomplish the same thing with `genfromtxt( file, opt_args,...).T` Reload the spectral data and reproduce the plot above using `loadtxt` or `genfromtxt`. **Hint:** You may find it helpful to use `numpy.split( array, N )`, which splits `array` into`N` equal-length parts, and returns them as a list. | # Same plot as before but now using numpy functions to load the data
import numpy as np
mass, charge = np.loadtxt('BaBar_2016.dat', unpack = True)
plt.plot(mass, charge,'r-')
plt.xlim(0, 8)
plt.ylim(0, 2e-3)
plt.xlabel('mass (GeV)')
plt.ylabel('charge, 90% C.L. limit')
plt.show() | _____no_output_____ | BSD-3-Clause | Week05/WS04/Workshop04.ipynb | ds-connectors/Physics-88-Fa21 |
Practice: Writing and Reading CSV files CSV stands for Comma Separated Values. Python's `csv` module allows easy reading and writing of sequences. CSV is especially useful for loading data from spreadsheets and databases. Let's make a list and write a file! First, we need to load a new module that you have not used yet in this course: `csv` | import csv | _____no_output_____ | BSD-3-Clause | Week05/WS04/Workshop04.ipynb | ds-connectors/Physics-88-Fa21 |
Next, just as before we need to create an abstract file object that opens the file we want to write to. Then, we create another programming abstraction called a *csv writer*, a special object that is built specifically to write sequences to our csv file. In this example, we have called the abstract file object `f_csv` and we have called the abstract csv writer object `SA_writer` | f_csv = open( 'nationData.csv', 'w' )
SA_writer = csv.writer( f_csv, # write to this file object
delimiter = '|', # place vertical bar between items we write
quotechar = '', # Don't place quotes around strings
quoting = csv.QUOTE_NONE )# made up of multiple words | _____no_output_____ | BSD-3-Clause | Week05/WS04/Workshop04.ipynb | ds-connectors/Physics-88-Fa21 |
Make sure that you understand at this point that all we have done is create a writer. It has not written anything to the file yet. So let's try to write the following lists of data: | countries = ['Argentina', 'Bolivia', 'Brazil', 'Chile', 'Colombia', 'Ecuador', 'Guyana',\
'Paraguay', 'Peru', 'Suriname', 'Uruguay', 'Venezuela']
capitals = ['Buenos Aires', 'Sucre', 'Brasília', 'Santiago', 'Bogotá', 'Quito', 'Georgetown',\
'Asunción', 'Lima', 'Paramaribo', 'Montevideo', 'Caracas']
population_mils = [ 42.8, 10.1, 203.4, 16.9, 46.4, 15.0, 0.7, 6.5, 29.2, 0.5,\
3.3, 27.6] | _____no_output_____ | BSD-3-Clause | Week05/WS04/Workshop04.ipynb | ds-connectors/Physics-88-Fa21 |
Now let's figure out how to add a line to our CSV file. For a regular ASCII file, we added lines by calling the `write` function. For a CSV file, we use a function called `writerow` which is attributed to our abstract csv writer `SA_writer`: | SA_writer.writerow(['Data on South American Nations'])
SA_writer.writerow(['Country', 'Capital', 'Populaton (millions)'])
for i in range(len(countries)):
SA_writer.writerow( [countries[i], capitals[i], population_mils[i]] )
f_csv.close() | _____no_output_____ | BSD-3-Clause | Week05/WS04/Workshop04.ipynb | ds-connectors/Physics-88-Fa21 |
Now let's see if we can open your file using a SpreadSheet program. If you don't have access to one, find someone who does! * Download nationData.csv* Open Microsoft Excel (or equivalent), and select "Import Data." * Locate nationData.csv in the list of files that pops up. * Select the "Delimited" Option in the next dialog box, and hit "Next"* Enter the appropriate delimiter in the next pop-up box, and hit finish.How did we do? **Practice 5:** Use syntax learned above to generate a csv file called `sine.csv` with pairs of x and y values separated by a comma. It should end up looking sort of like 0.0,0.0 1.57079632679,1.00000000Notice a few things: we don't need to use any formatting of the numbers. It doesn't matter how many decimal places each value has on each line. Python will just use the comma to figure out where one number ends and another begins We can use a similar process to *read* data from a csv file back into Python. Let's read in a list of the most populous cities from `cities.csv` and store them for analysis. | cities = []
cityPops = []
metroPops = []
f_csv = open( 'cities.csv', 'r')
readCity = csv.reader( f_csv, delimiter = ',' )
# The following line is how we skip a line in a csv. It is the equivalent of readline from before.
next(readCity) # skip the header row
for row in readCity:
print(row)
f_csv.close() | _____no_output_____ | BSD-3-Clause | Week05/WS04/Workshop04.ipynb | ds-connectors/Physics-88-Fa21 |
Look at the output of the code above. Every `row` that is read in is a `list` of `strings` by default again. So in order to use the numbers *as numbers* we need to convert them using the `float()` operation. Below, we use this to figure out which city has the largest city population: | f_csv = open( 'cities.csv', 'r')
readCity = csv.reader( f_csv, delimiter = ',' )
largest_city_pop = 0.0
city_w_largest_pop = None
# The following line is how we skip a line in a csv. It is the equivalent of readline from before.
next(readCity) # skip the header row
for row in readCity:
city_country = ', '.join(row[0:2]) # joins the city and country strings using a comma, like "Shanghai, China"
cityPop = float(row[2])
metroPop = float(row[3])
# if the population of this city is the largest seen so far, update
if cityPop > largest_city_pop:
largest_city_pop = cityPop
city_w_largest_pop = city_country
f_csv.close()
print("The city with the largest population is: %s with a population of %.1f million people" % (city_w_largest_pop, largest_city_pop)) | _____no_output_____ | BSD-3-Clause | Week05/WS04/Workshop04.ipynb | ds-connectors/Physics-88-Fa21 |
**Practice 6:** Use the syntax learned above to read in the x and y values from your `sine.csv` file. Plot your data to be sure you did everything correctly. | # Code for Practice 6 | _____no_output_____ | BSD-3-Clause | Week05/WS04/Workshop04.ipynb | ds-connectors/Physics-88-Fa21 |
Exercises **Exercise 1:** This exercise is meant to put many of the skills you have practiced thus far together. In this exercise, we are going to use I/O methods to see if we can find some correlations in some fake housing data. You will need the following files which should be in your directory: house_locs_rent.txt bus_stops.txt grocery_stores.txtThe file `house_locs_rent.txt` is a list of the locations of 500 houses and ther respective rents, and it has 3 columns: x-coordinate y-coordinate rent (in USD)The file `bus_stops.txt` is a list of the locations of bus stops and it has 2 columns: x-coordinate y-coordinateThe file `grocery_stores.txt` is a list of the locaitons of grocery stores and it has 2 columns: x-coordinate y-coordinateAll 3 files have one-line headers that you will want to ignore when loading the data. The goal of the exercise is to determine how much of the variation in the rent is predicted by variation in the distance between a house and its closest bus stop or by the distance between a house and its closest grocery store.To determine this, for each of the 500 houses, you will need to first calculate its distance to its nearest bus stop and its distance to its nearest grocery store.Then, we will use a measure called the Pearson correlation coefficient (which you will use in Homework04) to give an estimate of how much of the variation in the rent is predicted by variation in these distances. The Pearson correlation coefficient is defined as follows: Correlation CoefficientSuppose I have $N$ data points each with two variables $X_i$ and $Y_i$, where $i = 1\dots N$. Suppose I want to know how much of the variation in $Y$ is predicted by the variation in $X$. The correlation coefficient $R$ is a value between -1 and 1 with the following meaning: when $R=0$, $X$ and $Y$ are independent of each other. When $R>0$, we say they are positively correlated because if $X$ increases we can expect that $Y$ will increase as well. When $R<0$ we say they are negatively or oppositely correlated because if $X$ increases we can expect that $Y$ will decrease. $R$ is defined as follows:$$R = \frac{\mathbb{E}[(X_i - \mu_X)(Y_i - \mu_Y)]}{\sigma_X \sigma_Y} = \frac{1}{N \sigma_X \sigma_Y} \sum_{i=1}^N (X_i - \mu_X)(Y_i - \mu_Y)$$where $\mu_X$ is the average of $X_i$ over the dataset, $\mu_Y$ is the average of $Y_i$ over the dataset, $\sigma_X$ is the standard deviation of $X_i$ over the dataset, and $\sigma_Y$ is the standard deviation of $Y_i$ over the dataset. For calculating those quantities, you may find `np.mean()` and `np.std()` helpful.**However**, you must write your *own* correlation coefficient function. It can use `np.mean()` and `np.std()` but it should not call `np.cov` or `np.corrcoef` . **Output:** Your code should contain a function to calculate correlation coefficients as well as any other functions that you want to write (for example, a distance function, a minimum distance function...). The output should be the correlation coefficients between the pairs of variables (minimum distances to bus stops, minimum distances to grocery stores, rents) appropriately labeled. Also, create a CSV file titled `distances_rents.csv` and write the values of the minimum distances to the bus_stop and grocery store for each house along with its rent. For example, if the closest bus stop to the first house is 0.5 away and the closest grocery store to the first house is 1.5 away and the rent of the first house is 1250, then the first line of the CSV should read: 0.5,1.5,1250**Optional:** See if you can guess how I generated this fake data. To help sharpen your guess, try transforming the variables before computing the correlation coefficients. If the magnitude of the correlation coefficients goes up, that can be an indicator that you have found the correct form of the function. | # Code for Exercise 1 goes here | _____no_output_____ | BSD-3-Clause | Week05/WS04/Workshop04.ipynb | ds-connectors/Physics-88-Fa21 |
OPTIONAL: Practice With HDF5 Files So far you have encountered a standard ASCII text file and a CSV file. The next file format is called an HDF5 file. HDF5 files are ideally suited for managing large amounts of complex data. Python can read them using the module `h5py.` | import h5py | _____no_output_____ | BSD-3-Clause | Week05/WS04/Workshop04.ipynb | ds-connectors/Physics-88-Fa21 |
Let's load our first hdf5 file into an abstract file object. We call ours `fh5` in the example below: | fh5 = h5py.File( 'solar.h5py', 'r' ) | _____no_output_____ | BSD-3-Clause | Week05/WS04/Workshop04.ipynb | ds-connectors/Physics-88-Fa21 |
Here is how data is stored in an HDF5 file: hdf5 files are made up of data sets Each data set has a name. The correct Python terminology for this is "key". Let's take a look at what data sets are in `solar.h5py`. You can access the names (keys) of these data sets using the `.keys()` function: | for k in fh5.keys(): # loop through the keys
print(k) | _____no_output_____ | BSD-3-Clause | Week05/WS04/Workshop04.ipynb | ds-connectors/Physics-88-Fa21 |
To access one of the 6 data sets above, we need to use its name from above. Here we access the data set called `"names"`: | for nm in fh5["names"]: # make sure to include the quotation marks!
print(nm) | _____no_output_____ | BSD-3-Clause | Week05/WS04/Workshop04.ipynb | ds-connectors/Physics-88-Fa21 |
So the dataset called `"names"` contains 8 elements (poor Pluto) which are strings. In this HDF5 file, the other data sets contain `float` values, and can be treated like numpy arrays: | print(fh5["solar_AU"][::2])
print(fh5["surfT_K"][fh5["names"]=='Earth']) | _____no_output_____ | BSD-3-Clause | Week05/WS04/Workshop04.ipynb | ds-connectors/Physics-88-Fa21 |
Let's make a plot of the solar system that shows each planet's: * distance from the sun (position on the x-axis)* orbital period (position on the y-axis* mass (size of scatter plot marker)* surface temperature (color of marker)* density (transparency (or alpha, in matplotlib language)) | distAU = fh5["solar_AU"][:]
mass = fh5["mass_earthM"][:]
torb = fh5["TOrbit_yr"][:]
temp = fh5["surfT_K"][:]
rho = fh5["density"][:]
names = fh5["names"][:]
def get_size( ms ):
m = 400.0/(np.max(mass) - np.min(mass))
return 100.0 + (ms - np.min(mass))*m
def get_alpha( p ):
m = .9/(np.max(rho)-np.min(rho))
return .1+(p - np.min(rho))*m
alfs = get_alpha(rho)
import matplotlib as mpl
import matplotlib.pyplot as plt
norm = mpl.colors.Normalize(vmin=np.min(temp), vmax=np.max(temp))
cmap = plt.cm.cool
m = plt.cm.ScalarMappable(norm=norm, cmap=cmap)
fig, ax = plt.subplots(1)
for i in range(8):
ax.scatter( distAU[i], torb[i], s = get_size(mass[i]), color = m.to_rgba(temp[i]), alpha=alfs[i] )
ax.set_xscale('log')
ax.set_yscale('log')
ax.set_ylim(-5,200)
ax.set_ylabel( 'orbital period (y)' )
ax.set_xlabel( 'average dist. from sun (AU)' )
ax.set_title( 'Our solar system' ) | _____no_output_____ | BSD-3-Clause | Week05/WS04/Workshop04.ipynb | ds-connectors/Physics-88-Fa21 |
Play around with the data and see what interesting relationships you can find! If you ever want to write your own HDF5 file, you can open an h5py file object by calling: fh5 = h5py.File('filename.h5py', 'w') Data sets are created with dset = fh5.create_dataset( "dset_name", (shape,)) The default data type is float. The values for the data set are then set with: dset[...] = ( ) where the parenthesis contain an array or similar data of the correct shape. After you've added all your data sets, close the file with fh5.close() If you have extra time, try creating your own data set and read it back in to verify that you've done it correctly! OPTIONAL: Practice With Binary Files So far, we've been dealing with text files. If you opened these files up with a text editor, you could see what was written in them. Binary files are different. They're written in a form that Python (and other languages) understand how to read, but we can't access them directly. The most common binary file you'll encounter in python is a *.npy* file, which stores numpy arrays. You can create these files using the command `np.save( filename, arr )`. That command will store the array `arr` as a file called filename, which should have the extension .npy. We can then reload the data with the command `np.load(filename)` | x = np.linspace(-1, 1.0, 100)
y = np.sin(10*x)*np.exp(-x) - x
xy = np.hstack((x,y))
# save the array
np.save('y_of_x.npy', xy )
del x, y, xy # erase these variables from Python's memory | _____no_output_____ | BSD-3-Clause | Week05/WS04/Workshop04.ipynb | ds-connectors/Physics-88-Fa21 |
Now reload the data and check that you can use it just as before. Bonus challenge! Load the file `mysteryArray.npy`, and figure out the best way to plot it. **Hint:** look at the shape of the file, and the dimensions. | data = np.load('mysteryArray.npy') | _____no_output_____ | BSD-3-Clause | Week05/WS04/Workshop04.ipynb | ds-connectors/Physics-88-Fa21 |
maxima misc | kill(all)$
f(x) := 1/(x^2+l^2)^(3/2);
integrate(f(x), x);
tex(%)$ | _____no_output_____ | MIT | tests/notebooks/ipynb_maxima/maxima_example.ipynb | sthagen/mwouts-jupytext |
"Settling in France: The healthcare system"> The public healthcare system here is amazing- toc: true - badges: true- comments: true- categories:["french bureaucracy", Nancy, going to France]- image: images/chart-preview.png ---It is mandatory for all residents in France to register into the French healthcare system. ---Here you can tell they really see healthcare as a human right. ---The official [Campus France guide](https://www.campusfrance.org/en/registering-to-social-security) is very helpful.--- Setting it upGetting everything set up is really slow, but after that everything is really smooth. In my case everything took around 5 months to set up, but for other students it got to 8 months. Steps and documentsThe stages to get into the healthcare system are:- Initial registration- Getting a provisional number- Getting a definitive number- Applying for a *Carte Vitale*- Optional: Getting a *mutuelle* insurance- Optional: Applying for the *Complemaintaire*The documents necessary along the way are:- Passport- Residence permit- Proof of registration at a University for the current academic year- Birth certificate in the original language, translated if possible- IBAN bank account number- A French phone number Initial registrationIt is reallly important to do this ASAP after arriving to France, as the whole process is slown. Luckily, the initial registration completely online and really straight forward.1. Go to the [website for social security registration for foreign students](https://etudiant-etranger.ameli.fr//). 2. Specify your situation, date of birth, and nationality. - Note: I have heard some nationalities, like Canada, have different registration processes due to agreements with France. In any case, the website is really user-friendly and will guide you in everything you need.3. As an LCT student with a scholarship, my situation was "Student without employment"4. Then you will be prompted to a list of necessary documents:  They also explain what they mean by a "vital record":  - The "vital record" I used was my birth certificate in Spanish. 5. After the prompt with all the necessary documents, you will be asked to create an account. Here, a French phone number is necessary.6. Then you will be asked to upload the documents. If you don't have one available, you can always log in later to upload it.So, one mistake I made here was to wait until I had a bank account number (which took approximately one month) to start with the procedure. As the instructions on the website point out, there are two stages to get registered:- getting a provisional social security number- getting a definitive social security numberIt would have been faster for me if I had uploaded the documents for the provisional number as soon as I arrived in France. It is only after getting the provisional number that the process for a definitive number starts, so, I really did not have to wait until I had all the necessary documents for the definitive number.Anyway, after uploading the documents, you will see a "Processing" sign next to them. With this, the initial registration is done, and now you have to cross your fingers wishing they don't take long to process them. Getting a provisional numberAfter the initial registration, you just have to wait until they send you a letter in the mail with your provisional number.In my case, it took approximately two months to get this letter.However, other students had to wait for four to six months. In those cases, it was better to go to the social security office (called *Caisse Primaire d'Assurance Maladie (CPAM)*) and ask for the status of the process.- Even though in the websites of all *CPAM*s in France it says that you can only go there with an appointment (*rendez-vous*), you can really just go and wait in line.- It is way better to go with a native French speaker to help you, or even better, someone from France, who know a little more about the bureaucracy in this country.- In some cases, the *CPAM* had lost the uploaded documents, so some classmates had to show those documents in physical form there.- In some other cases, everything was fine, they were just being really slow with the documents. This was even slower with those documents written in a non-Latin script.Provisional numbers start with `7`, and once you get them you can go to the doctor. However, you will have to pay full price out-of-pocket, which is **25 €** for an appointment with a general practitioner (I don't know how much specialists charge). After that, there is a process where you can mail the receipt and some form in order to be partially reimbursed (I never had to do that because my definitive number didn't take that long to arrive).Once, you get a definitve number, it is way easier to go see a doctor. Getting a definitive number Approximately one month after getting my provisional number, I got another letter in the mail with my definitive number. From what I have heard from other students, this was a really short time.With the definitive number, you can go to see a doctor and have the social security system partially cover your expenses. For example, for appointments with general practitioners, **60-70%** is covered, so I ended up paying only **7 €** per appointment.In the same letter that notifed me about my definitive number, I received a form to apply for a *Carte Vitale*. Creating an *Ameli.fr* account[*Ameli.fr*](https://www.ameli.fr/) is the website of the social security system in France. After getting the definitive number, you can use it create an account there to follow your medical history (including reimbursements). You can also use it to do some bureaucracy. It is only available in French.  Using *FranceConnect*[*FranceConnect*](https://franceconnect.gouv.fr/) is an identification and authentification service from the French government. In short, it makes it so that you only need one account to do all the online bureaucracy, instead of creating an account for every public service. You can use your *Ameli.fr* account to create a *FranceConnect* account!  Applying for a *Carte Vitale*A *Carte Vitale* is just a card with your definitive social security number and your photo, which serves a proof of your registration in the French social security system.Once you have a *Carte Vitale*, when you go to a doctor's appointment or a pharmacy, they just scan it and the partial coverage is automatically applied!As I said, the form to apply for a *Carte Vitale* arrived in the same letter as my definitive number. This form is really easy to fill, I only needed- a photocopy of my passport- an ID photo- a signatureAlong with the form came an envelope and an address. I had to use this envelope to mail them the filled form back. Luckily, the envelope came already stamped, so I did not have to pay anything to send it back. I just went to a *La Poste* office, asked where to deposit my letter, and that was it.---Note: Once you get the form you only have 15 days to send it filled over the mail---After sending the form, I received my *Carte Vitale* in the mail in one month. Optional: getting a European Health Insurance CardOnce you have a *Carte Vitale* you can request an [European Health Insurance Card - EHIC](https://www.cleiss.fr/particuliers/ceam_en.html) using your *Ameli.fr* account. This card may be useful for having health coverage if you are travelling outside of France.   After requesting it, I had to wait for two weeks for it to arrive in the mail. Declaring a *médecin traitant*A *médecin traitant* is just your general practitioner doctor. In order to have the reimbursements work smoothly, you should declare one. In the same letter where my definitive number came, I got a form to declare a *médecin traitant*. I had to look for a doctor who spoke English or Spanish in *Doctolib* (see below). Once in the appointment, I had to ask the doctor to become my *médecin traitant*, they accepted and registered it in the system in just a couple of seconds. Optional: Getting a *mutuelle* The coverage of the French social security system is *partial*: you will still have to pay for doctor appointments, medicine, etc. To cover the remaining part of the cost, the French use a *mutuelle*, which is a kind of personal insurance, usually pay monthly.As an LCT student, I had an insurance provided by the programme, so I did **not** have to subscribe to a *mutuelle*. I am including it here for completeness. Optional: Applying for the *Complementaire* Again, the coverage of the French social security sytem is *partial*. Of course, each person has different economic circumsntances. The *Complementaire* exists for people who do not have enough ressources for covering all their health expenses: it entitles the holder for **total** coverage in some cases.In general, one should apply for the *Complementaire* online, but this service does not work for foreing residents in France: One has to deposit the necessary documents in the *CPAM* in person.I first had to go to the *CPAM* to ask for the necessary documents, and they gave me the following list for my particular situation (foreign student):- Passport photocopy- Student Visa photocopy- Certificate of enrolment in a French university- Certificate of *CAF* benefits (student housing subsidy) (to be explained in a future post)- Tax history in France *or* a sworn declaration of having no tax history in France- Residence Certificate (recent: < 3 months) : I got it at the reception in my residence- Proof of scholarship : I used the Erasmus Mundus scholarship letter- Student card photocopy- Proof of coverage by the public health system : *Attestation de droits* that I downloaded from my *Ameli.fr* account.- The application form for the *Complementaire* The application form for the *Complementaire* can be found online, in the *Ameli.fr* website. It is a little complicated to understand, so I recommend filling it with the help of a French speaker. Note:- One has to declare income of the last year. As I had not been working for more than a year by the time I applied to the *Complementaire*, the Erasmus scholarship was my only income. - Since I was a foreign student in France, I had not payed any taxes ever in France, so I had to write a sworn declaration stating that fact. I used a simple model: | #collapse-hide
"""
Attestation sur l’honneur de non-imposition
Je soussigné <M./Mme MY LAST NAME my name> demeurant <my address>,
Atteste sur l’honneur ne pas être soumis à l’impôt au titre des revenus de l’année 2020/2021.
Pour faire valoir ce que de droit
A Nancy, le ________________
"""; | _____no_output_____ | Apache-2.0 | _notebooks/2021-11-24-french_healtcare.ipynb | LuisAVasquez/quiescens-lct |
Principal Component Analysis (PCA) Introduction The purpose of this tutorial is to provide the reader with an intuitive understanding for principal component analysis (PCA). PCA is a multivariate data analysis technique mainly used for dimensionality reduction of large data sets. Working with large data sets is usually very complex as they contain large amount of information, which is difficult to comprehend. In order to find the patterns and correlations hidden on this data, PCA projects the original data into a variance space that contains a smaller number of latent variables called principal components. Each of these principal components, explain the amount of variation of the original data and it allows to explore how the instances differ from, and are similar to one another. For this tutorial, you will use the libraries listed below, which are already installed in Anaconda: | import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn
seaborn.set_style("white")
import sklearn
from sklearn.decomposition import PCA
%matplotlib inline | _____no_output_____ | MIT | 2016/tutorial_final/79/Tutorial.ipynb | zeromtmu/practicaldatascience.github.io |
On this tutorial, we will go step by step on how to implement principal component analysis (PCA) and then, we will use the sklearn library to compare the results. This tutorial is composed by the following sections: Data Loading Data Processing Mean-Centering Data Scaling Data Mathematical Computation PCA with sklearn Summary References Data Loading The dataset that we will be exploring in this tutorial comes from the U.S Energy Information Administration website: www.eia.gov . The data is provided in a weekly basis from February of 1991 to September of 2015 for the following variables with their respective units: Exports of Crude Oil (Thousand Barrels per Day) Commercial Crude Oil Imports Excluding SPR (Thousand Barrels per Day) Ending Stocks of Crude Oil and Petroleum Products (Thousand Barrels) Field Production of Crude Oil (Thousand Barrels per Day) Ending Stocks excluding SPR of Crude Oil (Thousand Barrels) Refiner Net Input of Crude Oil (Thousand Barrels per Day) Cushing OK WTI Spot Price FOB (Dollars per Barrel) Europe Brent Spot Price FOB (Dollars per Barrel) | dataset = pd.read_csv("tutorial_data1.csv")
dataset.head() | _____no_output_____ | MIT | 2016/tutorial_final/79/Tutorial.ipynb | zeromtmu/practicaldatascience.github.io |
Since the variables contain different dimensions, this will require some data processing that is described in the following section. Data Processing Mean-Centering Data The first step before applying PCA to a data matrix $X$ is to mean-center the data by making the mean of each variable to be zero. This is accomplished by finding the mean of each variable and substract it off to each of the instances belonging to that variable. | dataset_center = (dataset - dataset.mean())
dataset_center.round(2).head() | _____no_output_____ | MIT | 2016/tutorial_final/79/Tutorial.ipynb | zeromtmu/practicaldatascience.github.io |
Now, we need to find the covariance matrix of our dataset to see how the variables are correlated to each other. This is described by the following equation: $$ Cov(X) = \dfrac{\sum_{i=1}^{N}(x_{i} - \bar{x})(y_{i} - \bar{y})}{N-1}$$ where $N$ is the total number of rows, $\bar{x}$ and $\bar{y}$ are the means for the variables $x$ and $y$, respectively. | data_cov = dataset_center.cov()
data_cov = data_cov - data_cov.mean()
data_cov.round(2).head() | _____no_output_____ | MIT | 2016/tutorial_final/79/Tutorial.ipynb | zeromtmu/practicaldatascience.github.io |
The problem with the above matrix is that it depends on the units of the variables, so it is difficult to see the relationship between variables with different units. This requires you to scale the data and find the correlation matrix; which not only provides you with how the variables are related (positively/negatively), but also the degree to which they are related to each other. Note: If the variables in your data set have the same units, you don't need to scale the data. This means that you can work with the covariance matrix. Scaling Data Scaling the data to unit variance removes the problem of having variables with different dimensions. In addition, this ensures that we account for the variation of the instances, not for their magnitude. Below is the equation that describes this step: $$ x_{i,j} = \dfrac{{x_{i,j} - \bar{x_{j}}}}{\sqrt{\sum_{i=1}^{N}\dfrac{(x_{i,j} - \bar{x_{j}})^2}{N}}} $$ where ${N}$ is the total number of rows, $\bar{x}$ is the mean of column $j$, and $i$ and $j$ represent the row and column number, respectively. | # Scale data, ddof is set to 0 since we are using N not (N-1); which is the default for std in pandas
dataset_scale = (dataset_center)/(dataset_center.std(ddof = 1))
# Correlation matrix
data_corr = dataset_scale.corr()
#Changing the names for the columns and indexes
data_corr.columns = ['Exports of Crude Oil', 'Imports Excluding SPR', 'Ending Stocks of Crude Oil',
'Field Production', 'Ending Stocks excluding SPR', 'Refiner Net Input', 'WTI Spot', 'Brent Spot' ]
data_corr.index = ['Exports of Crude Oil', 'Imports Excluding SPR', 'Ending Stocks of Crude Oil',
'Field Production', 'Ending Stocks excluding SPR', 'Refiner Net Input', 'WTI Spot', 'Brent Spot' ]
data_corr.round(2) | _____no_output_____ | MIT | 2016/tutorial_final/79/Tutorial.ipynb | zeromtmu/practicaldatascience.github.io |
Mathematical Computation The next step is to find the eigenvalues and eigenvectors of our matrix. But before doing so, we will need to go over some linear algebra concepts that are essential for understanding PCA. As mentioned in the introduction, PCA is a projection method that maps the data into a different space whose axes are called principal components (PC). In order to do so, eigendecomposition is applied to the covariance matrix (in our case, the correlation matrix): $$Cov(X) = V\Lambda V^{-1} $$ where $V$ is a square matrix whose rows represent the eigenvectors of $Cov(X)$, and $\Lambda$ is a diagonal matrix whose diagonal elements are the eigenvalues of $Cov(X)$. The eigenvectors $v_{1}, v_{2},..., v_{n}$ are produced by the linear combination of the original variables $X_{1}, X_{2},..., X_{p}$ as shown below: $$v_{n} = w_{n1}X_{1} + w_{n2}X_{2} + ... + w_{np}X_{p}$$ where $w_{np}$ represents the weight of each variable and the eigenvectors are the actual principal components. | # Finding eigenvalues(w) and eigenvectors(v)
w, v = np.linalg.eig(data_corr)
print "Eigenvalues:"
print w.round(3)
print "Eigenvectors:"
print v.round(3) | Eigenvalues:
[ 3.222 2.806 1.14 0.008 0.08 0.309 0.187 0.249]
Eigenvectors:
[[-0.104 0.492 -0.347 -0.042 0.192 -0.114 0.18 0.736]
[-0.081 -0.5 -0.401 -0.018 -0.594 -0.412 0.162 0.184]
[-0.498 0.044 0.234 0.013 -0.161 -0.159 -0.772 0.218]
[-0.142 0.539 -0.133 0.03 -0.673 0.403 0.077 -0.222]
[-0.387 0.335 -0.034 0.032 0.154 -0.652 0.223 -0.488]
[-0.254 -0.149 -0.763 0.01 0.315 0.293 -0.276 -0.265]
[-0.495 -0.214 0.172 0.693 0.073 0.246 0.341 0.129]
[-0.505 -0.187 0.183 -0.718 0.054 0.244 0.311 0.047]]
| MIT | 2016/tutorial_final/79/Tutorial.ipynb | zeromtmu/practicaldatascience.github.io |
The eigenvalues represent the amount of variation contained by each of the principal components. The purpose of finding these values is to obtain the number of components that provide a reasonable generalization of the entire data set; which would be less than the total number of variables in the data. In order to determine the number of components that account for the largest variation in our data set, the scree plot is implemented as shown in the chart below: | plt.figure(figsize=(16,10))
# Scree Plot
plt.subplot(221)
plt.plot([1,2,3,4,5,6,7,8], w, 'ro-')
plt.title('Scree Plot', fontsize=16, fontweight='bold')
plt.xlabel('Principal Components', fontsize=14, fontweight='bold')
plt.ylabel('Eigenvalues', fontsize=14, fontweight='bold')
# Cumulative Explained Variation
plt.subplot(222)
plt.plot([1,2,3,4,5,6,7,8], (w*100/sum(w)).cumsum(), 'bo-')
plt.title('Cumulative Explained Variation', fontsize=16, fontweight='bold')
plt.xlabel('Principal Components', fontsize=14, fontweight='bold')
plt.ylabel('Amount of Variation (%)', fontsize=14, fontweight='bold') | _____no_output_____ | MIT | 2016/tutorial_final/79/Tutorial.ipynb | zeromtmu/practicaldatascience.github.io |
As you can see in the scree plot, the value of the eigenvalues drop significantly between PC3 and PC4 and it is not very clear how many components represent the data set. As a result, the cumulative explained variation is plotted and it clearly shows that the first 3 components account for approximately 90% of the variation of the data. Now that we have determined the number of PCs, we can map the scale data into the new coordinate system governed by the principal components. This mapped dataset is called in PCA, the scores: $$ scores = XV^{T} $$ where $V$ is a matrix with the number of PCs that explain most of the variation of the data. For visualization purposes, we will only use the first two components which account for ~ 75% of the total variation. | # Scores
scores = (dataset_scale.as_matrix()).dot(v[:,:2])
scores | _____no_output_____ | MIT | 2016/tutorial_final/79/Tutorial.ipynb | zeromtmu/practicaldatascience.github.io |
Having the scores allows us to observe the direction of the principal components in the x-y axis as shown in the following graph: | plt.figure(figsize=(10,8))
# Principal Components
pc1 = v[:, 0]
pc2 = v[:, 1]
pc1x = []
pc2x = []
pc1y = []
pc2y = []
# Plotting the scaled data and getting the values of the PCs
for ii, jj in zip(scores, dataset_scale.as_matrix()):
pc1x.append(pc1[0]*ii[0]), pc1y.append(pc1[1]*ii[0])
pc2x.append(pc2[0]*ii[1]), pc2y.append(pc2[1]*ii[1])
plt.scatter(jj[0], jj[1], color = 'b', marker = 'o')
# Fitting PC1 as a line
fit_pc1 = np.polyfit(pc1x, pc1y, 1)
line_pc1 = np.poly1d(fit_pc1)
new_points_pc1 = np.arange(-2,4)
plt.plot(new_points_pc1, line_pc1(new_points_pc1), 'g-', label= "PC1")
# Fitting PC2 as a line
fit_pc2 = np.polyfit(pc2x, pc2y, 1)
line_pc2 = np.poly1d(fit_pc2)
new_points_pc2 = np.arange(-2,4)
plt.plot(new_points_pc2, line_pc2(new_points_pc2), 'r-', label= "PC2")
plt.xlim([-2, 3])
plt.ylim([-3, 2])
plt.title('Scaled Data with the Principal Components', fontsize=16, fontweight='bold')
plt.xlabel('Exports of Crude Oil', fontsize=14, fontweight='bold')
plt.ylabel('Imports Excluding SPR', fontsize=14, fontweight='bold')
plt.legend(prop={'size':13, 'weight':'bold'}, frameon=True) | _____no_output_____ | MIT | 2016/tutorial_final/79/Tutorial.ipynb | zeromtmu/practicaldatascience.github.io |
As you can see above, the principal components are orthogonal (perpendicular) to each other, which is expected as this is an attribute of eigenvectors. Visually, PC1 and PC2 seem to capture a similar amount of variation and this correlates with the eigenvalues obtained whose values are 3.222 and 2.806 for PC1 and PC2, respectively. Now we will use the most important visualization plot of PCA, called the biplot. Here we will plot the scores along with the weights of the principal components, which are also called the loadings and represent the direction of the variables of $X$. The scores are plotted as data points, while the loadings will be plotted as vectors | plt.figure(figsize=(10,8))
for i in scores:
plt.scatter(i[0], i[1], color = 'b')
plt.xlim([-5, 3])
plt.ylim([-6, 4])
plt.title('Biplot', fontsize=16, fontweight='bold')
plt.xlabel('PC1 (40.3%)', fontsize=14, fontweight='bold')
plt.ylabel('PC2 (35.1%)', fontsize=14, fontweight='bold')
# Labels for the loadings
names = list(data_corr.columns)
#Transposing the eigenvectors
v_t = v[:,:2]
pc_1 = v_t[:, 0]
pc_2 = v_t[:, 1]
# Plotting the loadings as vectors
# The vectors are multiply by 4 due to visualization purposes
for i in range(len(pc_1)):
plt.arrow(0, 0, pc_1[i]*5, pc_2[i]*5, color='r', width=0.002, head_width=0.045)
plt.text(pc_1[i]*5, pc_2[i]*5, names[i], color='r') | _____no_output_____ | MIT | 2016/tutorial_final/79/Tutorial.ipynb | zeromtmu/practicaldatascience.github.io |
As you can see above, some of the variables are close to each other and this means that they are strongly related to one another. The actual correlation can be obtained by calculating the cosine of the angle between the variables. In addition, you can look back at the correlation matrix to see if those variables have a strong correlation. For example, the WTI and Brent spot prices vectors are very close to each other and their correlation value in the correlation matrix is 99%. The data points on the right-hand side of the plot, will certainly have low values as they are in the opposite direction of the variables. PCA with sklearn On this section, we will apply PCA directly to the scaled data using the sklearn decomposition library. First, define the number of components that you want (from the previous section, we found that 3 components explained most of the variation of the data, but 2 were chosen for visualization purposes). | pca = PCA(n_components=2) | _____no_output_____ | MIT | 2016/tutorial_final/79/Tutorial.ipynb | zeromtmu/practicaldatascience.github.io |
Second, fit the scaled data to PCA to find the eigenvalues and eigenvectors | pca.fit(dataset_scale.as_matrix())
# Eigenvectors
print "Eigenvectors:"
print pca.components_
print
# Eigenvalues
print "Eigenvalues:"
print pca.explained_variance_
print
# Variance explained
print "Amount of variance explained per component (%)"
print pca.explained_variance_ratio_*100 | Eigenvectors:
[[-0.10390372 -0.08094858 -0.4979827 -0.14178406 -0.38709197 -0.25433889
-0.4946933 -0.50528402]
[-0.49233521 0.49995417 -0.04365996 -0.53907923 -0.33467661 0.14923826
0.21430968 0.18689607]]
Eigenvalues:
[ 3.21945411 2.80348497]
Amount of variance explained per component (%)
[ 40.27451837 35.07085462]
| MIT | 2016/tutorial_final/79/Tutorial.ipynb | zeromtmu/practicaldatascience.github.io |