Naïve Bayes Algorithm
from array import *
T=[
['<=30', 'high', 'n', 'fair','n'],
['<=30', 'high', 'n', 'exe', 'n'],
['3140', 'high', 'n', 'fair', 'y'],
['40', 'medium', 'n', 'fair', 'y'],
['40', 'w', 'y', 'fair', 'y'],
['40', 'w', 'y', 'exe', 'n'],
['3140', 'w', 'y', 'exe', 'y'],
['<=30', 'medium', 'n', 'fair', 'n'],
['<=30', 'w', 'y', 'fair', 'y'],
['40', 'medium', 'y', 'fair', 'y'],
['<=30', 'medium', 'y', 'exe', 'y'],
['3140', 'medium', 'n', 'exe', 'y'],
['3140', 'high', 'y', 'fair', 'y'],
['40', 'medium', 'n', 'exe', 'n']
]
y=0
n=0
for record in T:
y += record[4].count('y')
print('No of Yes: ', y)
for record in T:
n += record[4].count('n')
print('No of No: ', n, '\n')
x1 = 0
for p1 in T:
x1 += p1[0].count('<=30') and p1[4].count('y')
y1 = 0
for p1 in T:
y1 += p1[0].count('<=30') and p1[4].count('n')
print('P(<=30)|YES: ', x1/y)
print('P(<=30)|NO: ', y1/n)
x2 = 0
for p1 in T:
x2 += p1[0].count('3140') and p1[4].count('y')
y2 = 0
for p1 in T:
y2 += p1[0].count('3140') and p1[4].count('n')
print('P(3140)|YES: ', x2/y)
print('P(3140)|NO: ', y2/n)
x3 = 0
for p1 in T:
x3 += p1[0].count('40') and p1[4].count('y')
y3 = 0
for p1 in T:
y3 += p1[0].count('40') and p1[4].count('n')
print('P(40)|YES: ', x3/y)
print('P(40)|NO: ', y3/n, '\n')
x4 = 0
for p1 in T:
x4 += p1[1].count('high') and p1[4].count('y')
y4 = 0
for p1 in T:
y4 += p1[1].count('high') and p1[4].count('n')
print('P(high)|YES: ', x4/y)
print('P(high)|NO: ', y4/n)
x5 = 0
for p1 in T:
x5 += p1[1].count('medium') and p1[4].count('y')
y5 = 0
for p1 in T:
y5 += p1[1].count('medium') and p1[4].count('n')
print('P(medium)|YES: ', x5/y)
print('P(medium)|NO: ', y5/n)
x6 = 0
for p1 in T:
x6 += p1[1].count('w') and p1[4].count('y')
y6 = 0
for p1 in T:
y6 += p1[1].count('w') and p1[4].count('n')
print('P(w)|YES: ', x6/y)
print('P(w)|NO: ', y6/n, '\n')
x7 = 0
for p1 in T:
x7 += p1[2].count('n') and p1[4].count('y')
y7 = 0
for p1 in T:
y7 += p1[2].count('n') and p1[4].count('n')
print('P(n)|YES: ', x7/y)
print('P(n)|NO: ', y7/n)
x8 = 0
for p1 in T:
x8 += p1[2].count('y') and p1[4].count('y')
y8 = 0
for p1 in T:
y8 += p1[2].count('y') and p1[4].count('n')
print('P(y)|YES: ', x8/y)
print('P(y)|NO: ', y8/n, '\n')
x9 = 0
for p1 in T:
x9 += p1[3].count('fair') and p1[4].count('y')
y9 = 0
for p1 in T:
y9 += p1[3].count('fair') and p1[4].count('n')
print('P(fair)|YES: ', x9/y)
print('P(fair)|NO: ', y9/n)
x10 = 0
for p1 in T:
x10 += p1[3].count('exe') and p1[4].count('y')
y10 = 0
for p1 in T:
y10 += p1[3].count('exe') and p1[4].count('n')
print('P(exe)|YES: ', x10/y)
print('P(exe)|NO: ', y10/n)
yes = x1/y * x5/y * x8/y * x9/y
nn = y1/n * y5/n * y8/n * y9/n
print('\nfor yes')
print (yes)
print('\nfor no')
print (nn)
KNN IMPLEMENTATION USING sklearn
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
url = "https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data"
# Assign colum names to the dataset
names = ['sepal-length', 'sepal-width', 'petal-length', 'petal-width', 'Class']
# Read dataset to pandas dataframe
dataset = pd.read_csv(url, names=names)
X = dataset.iloc[:, :-1].values
y = dataset.iloc[:, 4].values
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.40)
from sklearn.neighbors import KNeighborsClassifier
classifier = KNeighborsClassifier(n_neighbors=7,metric= 'euclidean')
classifier.fit(X_train, y_train)
y_pred = classifier.predict(X_test)
from sklearn.metrics import classification_report, confusion_matrix, accuracy_score
print("confusion_matrix \n", confusion_matrix(y_test, y_pred))
print(("accuracy_score ", accuracy_score (y_test, y_pred)))
print("\n",classification_report(y_test, y_pred))
PERCEPTRONS CODE-1
import numpy as np
class Perceptron(object):
def __init__(self, no_of_inputs, epoch=20, learning_rate=0.01):
self.epoch = epoch
self.learning_rate = learning_rate
self.weights = np.zeros(no_of_inputs + 1)
def predict(self, inputs):
summation = np.dot(inputs, self.weights[1:]) + self.weights[0]
if summation >= 0:
activation = 1
else:
activation = 0
return activation
def train(self, training_inputs, labels):
for _ in range(self.epoch):
for inputs, label in zip(training_inputs, labels):
prediction = self.predict(inputs)
self.weights[1:] += self.learning_rate * (label - prediction) * inputs
self.weights[0] += self.learning_rate * (label - prediction)
print("learning rate",self.learning_rate , self.weights[1:] )
training_inputs = []
training_inputs.append(np.array([1, 1]))
training_inputs.append(np.array([1, 0]))
training_inputs.append(np.array([0, 1]))
training_inputs.append(np.array([0, 0]))
labels = np.array([1, 0, 0, 0])
perceptron = Perceptron(2)
perceptron.train(training_inputs, labels)
inputs = np.array([0.5, 0.8])
print(perceptron.predict(inputs))
inputs = np.array([1.5, 0.5])
print(perceptron.predict(inputs))
PERCEPTRONS CODE-2
import numpy as np
class Perceptron(object):
def __init__(self, no_of_inputs, threshold=100, learning_rate=0.01):
self.threshold = threshold
self.learning_rate = learning_rate
self.weights = np.zeros(no_of_inputs + 1)
def predict(self, inputs):
summation = np.dot(inputs, self.weights[1:]) + self.weights[0]
if summation > 0:
activation = 1
else:
activation = 0
return activation
def train(self, training_inputs, labels):
for _ in range(self.threshold):
for inputs, label in zip(training_inputs, labels):
prediction = self.predict(inputs)
self.weights[1:] += self.learning_rate * (label - prediction) * inputs
self.weights[0] += self.learning_rate * (label - prediction)
KNAPSACK USING GENETIC ALGORITHM
import
random
import sys
import operator
class Knapsack(object):
#initialize variables and lists
def __init__(self):
self.C = 0
self.weights = []
self.profits = []
self.opt = []
self.parents = []
self.newparents = []
self.bests = []
self.best_p = []
self.iterated = 1
self.population = 0
# increase max recursion for long stack
iMaxStackSize = 15000
sys.setrecursionlimit(iMaxStackSize)
# create the initial population
def initialize(self):
for i in range(self.population):
parent = []
for k in range(0, 5):
k = random.randint(0, 1)
parent.append(k)
self.parents.append(parent)
# set the details of this problem
def properties(self, weights, profits, opt, C, population):
self.weights = weights
self.profits = profits
self.opt = opt
self.C = C
self.population = population
self.initialize()
# calculate the fitness function of each list (sack)
def fitness(self, item):
sum_w = 0
sum_p = 0
# get weights and profits
for index, i in enumerate(item):
if i == 0:
continue
else:
sum_w += self.weights[index]
sum_p += self.profits[index]
# if greater than the optimal return -1 or the number otherwise
if sum_w > self.C:
return -1
else:
return sum_p
# run generations of GA
def evaluation(self):
# loop through parents and calculate fitness
best_pop = self.population // 2
for i in range(len(self.parents)):
parent = self.parents[i]
ft = self.fitness(parent)
self.bests.append((ft, parent))
# sort the fitness list by fitness
self.bests.sort(key=operator.itemgetter(0), reverse=True)
self.best_p = self.bests[:best_pop]
self.best_p = [x[1] for x in self.best_p]
# mutate children after certain condition
def mutation(self, ch):
for i in range(len(ch)):
k = random.uniform(0, 1)
if k > 0.5:
#if random float number greater that 0.5 flip 0 with
1 and vice versa
if ch[i] == 1:
ch[i] = 0
else:
ch[i] = 1
return ch
# crossover two parents to produce two children by miixing them under
random ration each time
def crossover(self, ch1, ch2):
threshold = random.randint(1, len(ch1)-1)
tmp1 = ch1[threshold:]
tmp2 = ch2[threshold:]
ch1 = ch1[:threshold]
ch2 = ch2[:threshold]
ch1.extend(tmp2)
ch2.extend(tmp1)
return ch1, ch2
# run the GA algorithm
def run(self):
# run the evaluation once
self.evaluation()
newparents = []
pop = len(self.best_p)-1
# create a list with unique random integers
sample = random.sample(range(pop), pop)
for i in range(0, pop):
# select the random index of best children to randomize the
process
if i < pop-1:
r1 = self.best_p[i]
r2 = self.best_p[i+1]
nchild1, nchild2 = self.crossover(r1, r2)
newparents.append(nchild1)
newparents.append(nchild2)
else:
r1 = self.best_p[i]
r2 = self.best_p[0]
nchild1, nchild2 = self.crossover(r1, r2)
newparents.append(nchild1)
newparents.append(nchild2)
# mutate the new children and potential parents to ensure global
optima found
for i in range(len(newparents)):
newparents[i] = self.mutation(newparents[i])
if self.opt in newparents:
print ("optimal found in {} generations"
.format(self.iterated))
else:
self.iterated += 1
print("recreate generations for {} time"
.format(self.iterated))
self.parents = newparents
self.bests = []
self.best_p = []
self.run()
# properties for this particular problem
weights = [12, 7, 11, 8, 9]
profits = [24, 13, 23, 15, 16]
opt = [0, 1, 1, 1, 0]
C = 26
population = 10
k = Knapsack()
k.properties(weights, profits, opt, C, population)
k.run()
QUEENS PROBLEM USING GENETIC ALGORITHM
import
random
def random_chromosome(size): #making random chromosomes
return [ random.randint(1, nq) for _ in range(nq) ]
def fitness(chromosome):
horizontal_collisions = sum([chromosome.count(queen)-1 for queen in
chromosome])/2
diagonal_collisions = 0
n = len(chromosome)
left_diagonal = [0] * 2*n
right_diagonal = [0] * 2*n
for i in range(n):
left_diagonal[i + chromosome[i] - 1] += 1
right_diagonal[len(chromosome) - i + chromosome[i] - 2] += 1
diagonal_collisions = 0
for i in range(2*n-1):
counter = 0
if left_diagonal[i] > 1:
counter += left_diagonal[i]-1
if right_diagonal[i] > 1:
counter += right_diagonal[i]-1
diagonal_collisions += counter / (n-abs(i-n+1))
return int(maxFitness - (horizontal_collisions + diagonal_collisions)) #28-
(2+3)=23
def probability(chromosome, fitness):
return fitness(chromosome) / maxFitness
def random_pick(population, probabilities):
populationWithProbabilty = zip(population, probabilities)
total = sum(w for c, w in populationWithProbabilty)
r = random.uniform(0, total)
upto = 0
for c, w in zip(population, probabilities):
if upto + w >= r:
return c
upto += w
assert False, "Shouldn't get here"
def reproduce(x, y): #doing cross_over between two chromosomes
n = len(x)
c = random.randint(0, n - 1)
return x[0:c] + y[c:n]
def mutate(x): #randomly changing the value of a random index of a chromosome
n = len(x)
c = random.randint(0, n - 1)
m = random.randint(1, n)
x[c] = m
return x
def genetic_queen(population, fitness):
mutation_probability = 0.03
new_population = []
probabilities = [probability(n, fitness) for n in population]
for i in range(len(population)):
x = random_pick(population, probabilities) #best chromosome 1
y = random_pick(population, probabilities) #best chromosome 2
child = reproduce(x, y) #creating two new chromosomes from the best 2
chromosomes
if random.random() < mutation_probability:
child = mutate(child)
print_chromosome(child)
new_population.append(child)
if fitness(child) == maxFitness: break
return new_population
def print_chromosome(chrom):
print("Chromosome = {}, Fitness = {}"
.format(str(chrom), fitness(chrom)))
if __name__ == "__main__":
nq = int(input("Enter Number of Queens: ")) #say N = 8
maxFitness = (nq*(nq-1))/2 # 8*7/2 = 28
population = [random_chromosome(nq) for _ in range(100)]
generation = 1
while not maxFitness in [fitness(chrom) for chrom in population]:
print("=== Generation {} ===".format(generation))
population = genetic_queen(population, fitness)
print("")
print("Maximum Fitness = {}".format(max([fitness(n) for n in
population])))
generation += 1
chrom_out = []
print("Solved in Generation {}!".format(generation-1))
for chrom in population:
if fitness(chrom) == maxFitness:
print("");
print("One of the solutions: ")
chrom_out = chrom
print_chromosome(chrom)
board = []
for x in range(nq):
board.append(["x"] * nq)
for i in range(nq):
board[nq-chrom_out[i]][i]="Q"
def print_board(board):
for row in board:
print (" ".join(row))
print()
print_board(board)
Neo4j Sample Codeser
MATCH (A:Person)-[*3]->(b) WHERE A.name=”Alice” RETURN b
CREATE (ee:Person { name: "Emil", from: "Sweden", salary: “65.5k”}),
(js:Person { name: "Johan", from: "Sweden", learn: "surfing" }),
(ir:Person { name: "Ian", from: "England", title: "author" }),
(rvb:Person { name: "Rik", from: "Belgium", pet: "Orval" }),
(ally:Person { name: "Allison", from: "California", hobby: "surfing" })
RETURN ee,js,ir,rvb,ally
MATCH (ee:Person) where ee.name=’Emil’
MATCH(js:Person) where js.name=’Johan’
MATCH(ir:Person) where ir.name=’Ian’
MATCH (rvb:Person) where rvb.name= ‘Rik’
MATCH(ally:Person) where ally.name= ‘Allison’
CREATE (ee:Person { name: "Emil", from: "Sweden", salary: “65.5k”}),
(js:Person { name: "Johan", from: "Sweden", learn: "surfing" }),
(ir:Person { name: "Ian", from: "England", title: "author" }),
(rvb:Person { name: "Rik", from: "Belgium", pet: "Orval" }),
(ally:Person { name: "Allison", from: "California", hobby: "surfing" }),
(ee)-[:KNOWS {since: 2001}]->(js),(ee)-[:FRIEND {rating: 5}]->(ir),
(js)-[:KNOWS]->(ir),(js)-[:KNOWS]->(rvb),
(ir)-[:BOSS]->(js),(ir)-[:FRIEND]->(ally),
(rvb)-[:BROTHER]->(ally)
RETURN ee,js,ir,rvb,ally
MATCH (js:Person)-[:KNOWS]-()-[:KNOWS]-(surfer)
WHERE js.name = "Johan" AND surfer.hobby = "surfing"
RETURN DISTINCT surfer
MATCH (js:Person)-[:KNOWS]-()-[:FRIEND]-(surfer)
WHERE js.name = "Johan" AND surfer.hobby = "surfing"
RETURN DISTINCT surfer
