Lab 2


For each training example d, do:

     If d is positive example

         Remove from G any hypothesis h inconsistent with d

         For each hypothesis s in S not consistent with d:

              Remove s from S

              Add to S all minimal generalizations of s consistent with d and having a generalization in G

              Remove from S any hypothesis with a more specific h in S

     If d is negative example

          Remove from S any hypothesis h inconsistent with d

          For each hypothesis g in G not consistent with d:

                Remove g from G

                Add to G all minimal specializations of g consistent with d and having a specialization in S

                Remove from G any hypothesis having a more general hypothesis in G

Python Program to Implement and Demonstrate FIND-S Algorithm

import numpy as np 

import pandas as pd


data = pd.read_csv(path+'/enjoysport.csv')

concepts = np.array(data.iloc[:,0:-1])

print("\nInstances are:\n",concepts)

target = np.array(data.iloc[:,-1])

print("\nTarget Values are: ",target)


def learn(concepts, target): 

    specific_h = concepts[0].copy()

    print("\nInitialization of specific_h and genearal_h")

    print("\nSpecific Boundary: ", specific_h)

    general_h = [["?" for i in range(len(specific_h))] for i in range(len(specific_h))]

    print("\nGeneric Boundary: ",general_h)  

    for i, h in enumerate(concepts):

        print("\nInstance", i+1 , "is ", h)

        if target[i] == "yes":

            print("Instance is Positive ")

            for x in range(len(specific_h)): 

                if h[x]!= specific_h[x]:                    

                    specific_h[x] ='?'                     

                    general_h[x][x] ='?'

                   

        if target[i] == "no":            

            print("Instance is Negative ")

            for x in range(len(specific_h)): 

                if h[x]!= specific_h[x]:                    

                    general_h[x][x] = specific_h[x]                

                else:                    

                    general_h[x][x] = '?'        

        

        print("Specific Bundary after ", i+1, "Instance is ", specific_h)         

        print("Generic Boundary after ", i+1, "Instance is ", general_h)

        print("\n")


    indices = [i for i, val in enumerate(general_h) if val == ['?', '?', '?', '?', '?', '?']]    

    for i in indices:   

        general_h.remove(['?', '?', '?', '?', '?', '?']) 

    return specific_h, general_h 


s_final, g_final = learn(concepts, target)


print("Final Specific_h: ", s_final, sep="\n")

print("Final General_h: ", g_final, sep="\n")


Comments

Post a Comment

Popular posts from this blog

Lab 1 ai

 Dfs.pl s[a,b). s(a,c). s(b,d). s(b,e). s(c,f). s(c,g). s(d,h). s(e,i). s(e,j). s(f,k). goal(f). goal(j). solve(Start,Solution):- breadthfirst([[Start]],Solution). breadthfirst([[Node | Path] ].[Node|Path]]:- goal(Node). breadthfirst([Path | Paths] Solution):- extend(Path,NewPaths), write(NewPaths), nl, conc(Paths,NewPaths, Paths1), breadthfirst(Paths1,Solution). extend([NodePath],NewPaths):- bagof([NewNode, Node | Path),(s(Node, NewNode),not(member(NewNode, [Node | Path]))),NewPaths),!. extend([]). conc([],L,L). Scanned with OKEN Scanner bfs.pl s(a,b). s(a,c). s(b,d). s(b,e). s(c,f). s(c,g). / s(d,h). s(e,i). s(e,j). s(f,k). goal(f). goal(j). member(X,[X|_]). member(X,_|Tail]):- member(X,Tail). solve(Node,Solution):- depthfirst([],Node,Solution). depthfirst(Path, Node,[Node | Path]):- goal(Node). depthfirst(Path,Node,Sol):- s(Node,Node1), not(member(Node1,Path)), depthfirst([Node | Path], Node1,Sol). Scanned with OKEN Scanner conc([X/L1],L2,[X|L3]):- write('conc'), write(X), w...
Read more
 def aStarAlgo(start_node, stop_node): open_set = set(start_node) closed_set = set() g={} parents = {} g[start_node] = 0 parents[start_node] = start_node while len(open_set) > 0: n = None for v in open_set: if n == None or g[v] + heuristic(v) <g[n] + heuristic(n): n=v if n stop_node or Graph_nodes[n] == None: pass else: for (m, weight) in get_neighbors(n): open_set.add(m) if m not in open_set and m not in closed_set: parents[m] = n g[m] = g[n] + weight else: if g[m]g[n] + weight: g[m] = g[n] + weight parents[m] = n if m in closed_set: closed_set.remove(m) open_set.add(m) if n == None: print('Path does not exist!") return None if n == stop_node: path = [] while parents[n] != n: path.append(n) n = parents[n] path.append(start_node) path.reverse() print('Path found: {}'.format(path)) return path open_set.remove(n) closed_set.add(n) print('Path does not exist!") return None def get_neighbors(v): if v in Graph_nodes: return Graph_nodes[v] else: return None de...
Read more
 SuccList ={'A':[('B',3),('C',2)], 'B':[('A',5),('C',2),('D',2),('E',3)], 'C':[('A',5),('B',3),('F',2),('G',4)], 'D':[('H',1),('I',99)], 'F': [('J',99)], 'G':[('K',99),('L',3)]} Start='A' Goal='E' Closed = list() SUCCESS=True FAILURE=False State=FAILURE def MOVEGEN(N):     New_list=list()     if N in SuccList.keys():         New_list=SuccList[N]     return New_list def GOALTEST(N):     if N == Goal:         return True     else:         return False def APPEND(L1,L2):     New_list=list(L1)+list(L2)     return New_list def SORT(L):     L.sort(key = lambda x: x[1])     return L def BestFirstSearch():     OPEN=[[Start,5]]     CLOSED=list()     global State     global Closed     while (len(OPEN) != 0) and (State != SUCCESS):         print("-------------")     ...
Read more