asign1 https://notebooks.gesis.org/binder/jupyter/user/ipython-ipython-in-depth...

Set Operations

In [1]: b1=[1,0.15,0.3,0.5,0]
b2=[1,0.6,0.2,0.1,0]

In [2]: union=[]
for i in range(len(b1)):
union.append(max(b1[i],b2[i]))

In [3]: print(union)

[1, 0.6, 0.3, 0.5, 0]

In [4]: intersct=[]
for i in range(len(b1)):
intersct.append(min(b1[i],b2[i]))
print(intersct)

[1, 0.15, 0.2, 0.1, 0]

In [5]: comp1=[]
for i in range(len(b1)):
comp1.append(1-b1[i])
print(comp1)

[0, 0.85, 0.7, 0.5, 1]

In [6]: comp2=[]
for i in range(len(b2)):
comp2.append(1-b2[i])
print(comp2)

[0, 0.4, 0.8, 0.9, 1]

In [7]: diff12=[]
for i in range(len(b1)):
diff12.append(min(b1[i],comp2[i]))
print(diff12)

[0, 0.15, 0.3, 0.5, 0]

In [8]: diff21=[]
for i in range(len(b1)):
diff21.append(min(b2[i],comp1[i]))
print(diff21)

[0, 0.6, 0.2, 0.1, 0]

1 of 3 26-09-2020, 18:01
asign1 https://notebooks.gesis.org/binder/jupyter/user/ipython-ipython-in-depth...

In [9]: cartesianprod=[]
for i in range(len(b1)):
z=[]
cartesianprod.append(z)

for i in range(len(b1)):
for j in range(len(b1)):
cartesianprod[i].append(min(b1[i],b2[j]))
print(cartesianprod)

[[1, 0.6, 0.2, 0.1, 0], [0.15, 0.15, 0.15, 0.1, 0], [0.3, 0.3, 0.2,
0.1, 0], [0.5, 0.5, 0.2, 0.1, 0], [0, 0, 0, 0, 0]]

In [10]: from matplotlib import pyplot as plt

In [11]: x=[1,2,3,4,5]
plt.plot(x,b1,label="set 1")
plt.plot(x,b2,label="set 2")
plt.legend()

Out[11]: <matplotlib.legend.Legend at 0x7fe7849b4668>

2 of 3 26-09-2020, 18:01
asign1 https://notebooks.gesis.org/binder/jupyter/user/ipython-ipython-in-depth...

In [12]: plt.plot(x,union)

Out[12]: [<matplotlib.lines.Line2D at 0x7fe7848e66a0>]

In [13]: plt.plot(x,intersct)

Out[13]: [<matplotlib.lines.Line2D at 0x7fe78485b5c0>]

In [14]: r1=[[0.6,0.3],[0.2,0.9]]
r2=[[1,0.5,0.3],[0.8,0.4,0.7]]
t=[]
for i in range(len(r1)):
z=[]
t.append(z)

for i in range(len(r1)):
for j in range(len(r2)):
t[i].append(min(r1[i],r2[j]))
print(t)

[[[0.6, 0.3], [0.6, 0.3]], [[0.2, 0.9], [0.2, 0.9]]]

In [ ]:

3 of 3 26-09-2020, 18:01
Single Layer Perceptron

import numpy as np

def unit_step(v):
""" Heavyside Step function. v must be a scalar """
if v >= 0:
return 1
else:
return 0

def perceptron(x, w, b):

v = np.dot(w, x) + b
y = unit_step(v)
return y

def NOT_percep(x):
return perceptron(x, w=-1, b=0.5)

print("NOT(0) = {}".format(NOT_percep(0)))
print("NOT(1) = {}".format(NOT_percep(1)))

def AND_percep(x):
w = np.array([1, 1])
b = -1.5
return perceptron(x, w, b)

example1_and = np.array([1, 1])

example2_and = np.array([1, 0])
example3_and = np.array([0, 1])
example4_and = np.array([0, 0])

print("AND(1, 1) = "+str(AND_percep(example1_and)))
print("AND(1, 0) = "+str(AND_percep(example2_and)))
print("AND(0, 1) = "+str(AND_percep(example3_and)))
print("AND(0, 0) = "+str(AND_percep(example4_and)))

def OR_percep(x):
w = np.array([1, 1])
b = -0.5
return perceptron(x, w, b)

example1_or = np.array([1, 1])

example2_or = np.array([1, 0])
example3_or = np.array([0, 1])
example4_or = np.array([0, 0])

print("OR({}, {}) = {}".format(1, 1, OR_percep(example1_or)))

print("OR({}, {}) = {}".format(1, 0, OR_percep(example2_or)))
print("OR({}, {}) = {}".format(0, 1, OR_percep(example3_or)))
print("OR({}, {}) = {}".format(0, 0, OR_percep(example4_or)))

****************OUTPUT****************
NOT(0) = 1
NOT(1) = 0
AND(1, 1) = 1
AND(1, 0) = 0
AND(0, 1) = 0
AND(0, 0) = 0
OR(1, 1) = 1
OR(1, 0) = 1
OR(0, 1) = 1
OR(0, 0) = 0
PSO on Rosenbrock function

from pyswarms.single.global_best import GlobalBestPSO

# instatiate the optimizer

x_max = 10 * np.ones(2)

x_min = -1 * x_max

bounds = (x_min, x_max)

options = {'c1': 0.5, 'c2': 0.3, 'w': 0.9}

optimizer = GlobalBestPSO(n_particles=10, dimensions=2, options=options, bounds=bounds)

# now run the optimization, pass a=1 and b=100 as a tuple assigned to args

cost, pos = optimizer.optimize(rosenbrock_with_args, 1000, a=1, b=100, c=0)

# for c1=c2 = 2

options = {'c1': 2, 'c2': 2, 'w': 0.9}

optimizer = GlobalBestPSO(n_particles=10, dimensions=2, options=options, bounds=bounds)

cost, pos = optimizer.optimize(rosenbrock_with_args, 1000, a=1, b=100, c=0)

GA on Rosenbrock function
from __future__ import division

import random

'''

Abbreviations:

gen: generation, a set of peer solutions

sol: solution, coordinates with SOL_DIM dimensions

Rosenbrock function: f(x, y) = (a - x) ^ 2 + b * (y - x ^ 2) ^ 2

Example parameters: a = 1 and b = 100

Goal: find the closest solution to the min of f(x, y)

'''

GEN_SIZE = 100

GEN_COUNT = 100
BOUNDS = ((-100, 100), (-100, 100))

def random_generation():

generation = []

for _ in xrange(GEN_SIZE):

random_point = (random.randint(BOUNDS[0][0], BOUNDS[0][1]), random.randint(BOUNDS[1][0],

BOUNDS[1][1]))

generation.append(random_point)

return generation

def rosenbrock(solution):

return abs((1 - solution[0]) ** 2 + 100 * (solution[1] - solution[0] ** 2) ** 2)

def inverse(value):

if value == 0:

return 1

else:

return 1 / value

def fitness(solution):

return inverse(rosenbrock(solution))

def probability(fitness_score, total):

assert total != 0

return fitness_score / total

def weighted_choice(items):

weight_total = sum((item[1] for item in items))

n = random.uniform(0, weight_total)

for item, weight in items:

if n < weight:

return item

n = n - weight

return item
def crossover(solution1, solution2):

# pos = int(random.random() * 2) # this is a good line, but

pos = 1 # let's simplify

return solution1[:pos] + solution2[pos:], solution2[:pos] + solution1[pos:]

def mutate(solution):

tmp_sol = [solution[0], solution[1]]

mutation_threshold = 0.2

for i in range(len(solution)):

if random.random() > mutation_threshold:

tmp_sol[i] = random.randint(BOUNDS[i][0], BOUNDS[i][1])

mutated_sol = (tmp_sol[0], tmp_sol[1])

return mutated_sol

if __name__ == "__main__":

cur_gen_count = 0

gens = []

# Step 1. Create an initial generation

gen = random_generation()

gens.append(gen)

cur_gen_count += 1

# Step 2. Calculate fitness

fitness_scores = []

for sol in gen:

fitness_score = fitness(sol)

fitness_scores.append(fitness_score)

total_value = 0

for score in fitness_scores:

total_value += score

probas = []

for score in fitness_scores:

proba = probability(score, total_value)

probas.append(proba)

weighted_gen = []
for i, sol in enumerate(gen):

weighted_gen.append(((sol[0], sol[1]), probas[i]))

print "INITIAL GENERATION"

print "\tGENERATION #%s" % cur_gen_count

for i, sol in enumerate(weighted_gen):

print "\t\tSolution #%s: %s, probability: %s%%" % \

(i + 1, sol[0], int(sol[1] * 100))

# Step 3. Create next generations

print "NEXT GENERATIONS"

for _ in xrange(GEN_SIZE - cur_gen_count):

gen = []

cur_gen_count += 1

print "\tGENERATION #%s" % cur_gen_count

for pair_i in xrange(int(GEN_SIZE / 2)):

# Step 3.a Select parents

print "\t\tPair #%s" % (pair_i + 1)

parent1 = weighted_choice(weighted_gen)

parent2 = weighted_choice(weighted_gen)

print "\t\t\tParent 1: %s, Parent 2: %s" % (parent1, parent2)

# Step 3.b Create children

child1, child2 = crossover(parent1, parent2)

print "\t\t\tChild 1: %s, Child 2: %s" % (child1, child2)

# Step 3.c Mutate children

print '\t\t\tChild Mutation:'

child1 = mutate(child1)

child2 = mutate(child2)

print "\t\t\tChild 1: %s, Child 2: %s" % (child1, child2)

gen.append(child1)

gen.append(child2)

gens.append(gen)

print "LAST GENERATION"

print "\tGENERATION #%s" % cur_gen_count

weighted_gen = []

fitness_scores = []

for sol in gen:

fitness_score = fitness(sol)

fitness_scores.append(fitness_score)

total_value = 0

for score in fitness_scores:

total_value += score

probas = []

for score in fitness_scores:

proba = probability(score, total_value)

probas.append(proba)

weighted_gen = []

for i, sol in enumerate(gen):

weighted_gen.append(((sol[0], sol[1]), probas[i]))

for i, sol in enumerate(weighted_gen):

print "\t\tSolution #%s: %s, probability: %s%%" % \

(i + 1, sol[0], int(sol[1] * 100))

print("\nSUMMARY")

for gen_i, gen in enumerate(gens):

print "\tGENERATION #%s" % (gen_i + 1)

for sol in enumerate(gen):

print "\t\t", sol[1],

print

fittest_sol = gen[0]

fitness_max = fitness(gen[0])

for sol in gen:

sol_fitness = fitness(sol)

if sol_fitness >= fitness_max:

fittest_sol = sol

fitness_max = sol_fitness

print "\nFittest solution: ", fittest_sol

exit(0)