PROG2

-

 class Graph:

    def __init__(self, graph, heuristicNodeList, startNode):

        self.graph = graph

        self.H = heuristicNodeList

        self.start = startNode

        self.parent = {}

        self.status = {}

        self.solutionGraph = {}


    def applyAOStar(self):  # starts a recursive AO* algorithm

        self.aoStar(self.start, False)


    def getNeighbors(self, v):

        return self.graph.get(v, '')


    def getStatus(self, v):  # return the status of a given node

        return self.status.get(v, 0)


    def setStatus(self, v, val):  # set the status of a given node

        self.status[v] = val


    def getHeuristicNodeValue(self, n):

        return self.H.get(n, 0)


    def setHeuristicNodeValue(self, n, value):

        self.H[n] = value


    def printSolution(self):

        print("FOR GRAPH SOLUTION, TRAVERSE THE GRAPH FROM THE START NODE:", self.start)

        print("-----------------------------------------------")

        print(self.solutionGraph)

        print("-----------------------------------------------")


    def computeMinimumCostChildNodes(self, v):

        minimumCost = 0

        costToChildNodeListDict = {}

        costToChildNodeListDict[minimumCost] = []

        flag = True

        for nodeInfoTupleList in self.getNeighbors(v):

            cost = 0

            nodeList = []

            for c, weight in nodeInfoTupleList:

                cost = cost + self.getHeuristicNodeValue(c) + weight

                nodeList.append(c)

            if flag == True:

                minimumCost = cost

                costToChildNodeListDict[minimumCost] = nodeList

                flag = False

            else:

                if minimumCost > cost:

                    minimumCost = cost

                    costToChildNodeListDict[minimumCost] = nodeList

        return minimumCost, costToChildNodeListDict[minimumCost]


    def aoStar(self, v, backTracking):

        print("HEURISTIC VALUES :", self.H)

        print("SOLUTION GRAPH :", self.solutionGraph)

        print("PROCESSING NODE :", v)

        print("----------------------------------------------")

        if self.getStatus(v) >= 0:

            minimumCost, childNodeList = self.computeMinimumCostChildNodes(v)

            print(minimumCost, childNodeList)

            self.setHeuristicNodeValue(v, minimumCost)

            self.setStatus(v, len(childNodeList))

            solved = True

            for childNode in childNodeList:

                self.parent[childNode] = v

                if self.getStatus(childNode) != -1:

                    solved = solved & False

            if solved == True:

                self.setStatus(v, -1)

                self.solutionGraph[v] = childNodeList

                if v != self.start:

                    self.aoStar(self.parent[v], True)

            if backTracking == False:

                for childNode in childNodeList:

                    self.setStatus(childNode, 0)

                    self.aoStar(childNode, False)


print("Graph - 1")

h1 = {'A': 1, 'B': 6, 'C': 2, 'D': 12, 'E': 2, 'F': 1, 'G': 5,

      'H': 7, 'I': 7, 'J': 1}

graph1 = {

    'A': [[('B', 1), ('C', 1)], [('D', 1)]],

    'B': [[('G', 1)], [('H', 1)]],

    'C': [[('J', 1)]],

    'D': [[('E', 1), ('F', 1)]],

    'G': [[('I', 1)]]

}

G1 = Graph(graph1, h1, 'A')

G1.applyAOStar()

G1.printSolution()


Comments

Post a Comment

If you have any doubts let me know in comments

Popular posts from this blog

PROG9

-
 import matplotlib.pyplot as plt import pandas as pd import numpy as np def kernel(point, xmat, k):     m, n = np.shape(xmat)     weights = np.mat(np.eye((m)))  # eye - identity matrix     for j in range(m):         diff = point - X[j]         weights[j, j] = np.exp(diff * diff.T / (-2.0 * k**2))     return weights def localWeight(point, xmat, ymat, k):     wei = kernel(point, xmat, k)     W = (X.T * (wei * X)).I * (X.T * (wei * ymat.T))     return W def localWeightRegression(xmat, ymat, k):     m, n = np.shape(xmat)     ypred = np.zeros(m)     for i in range(m):         ypred[i] = xmat[i] * localWeight(xmat[i], xmat, ymat, k)     return ypred def graphPlot(X, ypred):     sortindex = X[:, 1].argsort(0)  # argsort - index of the smallest     xsort = X[sortindex][:, 0]     fig = plt.figure()     ax = fig.add_subplot(1, 1, 1)     ax.scatter(bill, tip, color='green')     ax.plot(xsort[:, 1], ypred[sortindex], color='red', linewidth=5)     plt.xlabel('Total bill')  
Read more

ADDING TABLE IN HTML

-
Image
TABLE IN HTML. We can create a Table in html and can list many items in a systematic way which looks good and neat whenever some one visits your page. there are few important tags in creation of a table. let us analyse them <table border="1"> through this tag we can set the border thickness,style and all... <tr> this specifies table row. </tr> closing table row. <th> table head it specifies the top heading of an item list. </th> closes the table head. lets see an example CODE OUTPUT
Read more

PROG8

-
 from sklearn.model_selection import train_test_split from sklearn.neighbors import KNeighborsClassifier from sklearn import datasets # Load dataset iris = datasets.load_iris() print("Iris Data set loaded...") # Split the data into train and test samples x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.1) print("Dataset is split into training and testing...") print("Size of training data and its label", x_train.shape, y_train.shape) print("Size of testing data and its label", x_test.shape, y_test.shape) # Prints Label no. and their names for i in range(len(iris.target_names)):     print("Label", i, "-", str(iris.target_names[i])) # Create object of KNN classifier classifier = KNeighborsClassifier(n_neighbors=12) # Perform Training classifier.fit(x_train, y_train) # Perform testing y_pred = classifier.predict(x_test) # Display the results print("Results of Classification using K-nn wi
Read more