人工智能实验室手册 使用Python的人工智能实验室

AILABMANUAL

ArtificialIntelligenceLabUsingPython(LC-CSE-326G)

DEPARTMENTOFCOMPUTERSCIENCE&ENGINEERING

ChecklistforLabManual

S.No.

Particulars

1

MissionandVision

2

CourseOutcomes

3

Guidelinesforthestudent

4

ListofProgramsasperUniversity

5

SamplecopyofFile

DepartmentofComputerScience&Engineering

VisionandMissionoftheDepartmentVision

TobeaModelinQualityEducationforproducinghighlytalentedandgloballyrecognizablestudentswithsoundethics,latestknowledge,andinnovativeideasinComputerScience&Engineering.

MISSION

TobeaModelinQualityEducationby

M1:Impartinggoodsoundtheoreticalbasisandwide-rangingpracticalexperiencetotheStudentsforfulfillingtheupcomingneedsoftheSocietyinthevariousfieldsofComputerScience&Engineering.

M2:OfferingtheStudentsanoverallbackgroundsuitableformakingaSuccessfulcareerinIndustry/Research/HigherEducationinIndiaandabroad.

M3:ProvidingopportunitytotheStudentsforLearningbeyondCurriculumandimprovingCommunicationSkills.

M4:EngagingStudentsinLearning,UnderstandingandApplyingNovelIdeas.

Course:ArtificialIntelligenceLabusingPythonCourseCode:LC-CSE-326G

CO(CourseOutcomes)

RBT*-RevisedBloom’s

Taxonomy

CO1

ToUseControlStructuresandOperatorstowritebasicPythonprogramming.

L3

(Apply)

CO2

ToAnalyzeobject-orientedconceptsinPython.

L4

(Analyze)

CO3

ToEvaluatetheAImodelspre-processedthroughvariousfeature

engineeringalgorithmsbyPythonProgramming.

L5

(Evaluate)

CO4

ToDevelopthecodefortherecommendersystemusingNatural

Languageprocessing.

L6

(Create)

CO5

ToDesignvariousreinforcementalgorithmstosolvereal-timecomplex

problems.

L6

(Create)

COPO-PSOArticulationMatrices

Course

Outcomes(COs)

(POs)

PSOs

PO1

PO2

PO3

PO4

PO5

PO6

PO7

PO8

PO9

PO10

PO11

PO12

PSO1

PSO2

CO1

3

2

1

3

2

CO2

2

2

3

2

1

2

2

CO3

2

3

2

2

1

2

2

CO4

2

2

2

3

2

1

1

2

CO5

2

2

2

3

2

1

2

1

GuidelinesfortheStudents:

Studentsshouldberegularandcomepreparedforthelabpractice.

Incaseastudentmissesaclass,itishis/herresponsibilitytocompletethatmissedexperiment(s).

Studentsshouldbringtheobservationbook,labjournalandlabmanual.Prescribedtextbookandclassnotescanbekeptreadyforreferenceifrequired.

TheyshouldimplementthegivenProgramindividually.

Whileconductingtheexperimentsstudentsshouldseethattheirprogramswouldmeetthefollowingcriteria:

Programsshouldbeinteractivewithappropriatepromptmessages,errormessagesifany,anddescriptivemessagesforoutputs.

Programsshouldperforminputvalidation(Datatype,rangeerror,etc.)andgiveappropriateerrormessagesandsuggestcorrectiveactions.

Commentsshouldbeusedtogivethestatementoftheproblemandevery

functionshouldindicatethepurposeofthefunction,inputsandoutputs

Statementswithintheprogramshouldbeproperlyindented

Usemeaningfulnamesforvariablesandfunctions.

MakeuseofConstantsandtypedefinitionswhereverneeded.

Oncetheexperiment(s)getexecuted,theyshouldshowtheprogramandresultstotheinstructorsandcopythesameintheirobservationbook.

Questionsforlabtestsandexamneednotnecessarilybelimitedtothequestionsinthemanual,butcouldinvolvesomevariationsand/orcombinationsofthequestions.

ListofExperiments:

WriteaProgramtoImplementBreadthFirstSearchusingPython.

WriteaProgramtoImplementDepthFirstSearchusingPython.

WriteaProgramtoImplementTic-Tac-ToegameusingPython.

WriteaProgramtoImplement8-PuzzleproblemusingPython.

WriteaProgramtoImplementWater-JugproblemusingPython.

Write a Program to Implement Travelling SalesmanProblemusingPython.

WriteaProgramtoImplementTowerofHanoiusingPython.

WriteaProgramtoImplementMonkeyBananaProblemusingPython.

WriteaProgramtoImplementAlpha-BetaPruningusingPython.

WriteaProgramtoImplement8-QueensProblemusingPython.

EXPERIMENT1

#WriteaProgramtoImplementBreadthFirstSearchusingPython.

graph={

'A':['B','C'],

'B':['D','E'],

'C':['F'],

'D':[],

'E':['F'],'F':[]

}

visited=[]#Listtokeeptrackofvisitednodes.queue=[] #Initializeaqueue

defbfs(visited,graph,node):

visited.append(node)queue.append(node)

whilequeue:

s=queue.pop(0)print(s,end="")

forneighbouringraph[s]:ifneighbournotinvisited:

visited.append(neighbour)queue.append(neighbour)

#DriverCodebfs(visited,graph,'A')

Output:-

ABCDEF

EXPERIMENT2

#WriteaProgramtoImplementDepthFirstSearchusingPython.

#UsingaPythondictionarytoactasanadjacencylistgraph={

'A':['B','C'],

'B':['D','E'],

'C':['F'],

'D':[],

'E':['F'],'F':[]

}

visited=set()#Settokeeptrackofvisitednodes.

defdfs(visited,graph,node):ifnodenotinvisited:

print(node)visited.add(node)

forneighbouringraph[node]:dfs(visited,graph,neighbour)

#DriverCodedfs(visited,graph,'A')

Output:-

ABDEFC

EXPERIMENT3

#WriteaProgramtoImplementTic-Tac-ToegameusingPython.

#Tic-Tac-ToeProgramusing#randomnumberinPython

#importingallnecessarylibrariesimportnumpyasnp

importrandom

fromtimeimportsleep

#Createsanemptyboarddefcreate_board():

return(np.array([[0,0,0],

[0,0,0],

[0,0,0]]))

#Checkforemptyplacesonboarddefpossibilities(board):

l=[]

foriinrange(len(board)):

forjinrange(len(board)):

ifboard[i][j]==0:

l.append((i,j))

return(l)

#Selectarandomplacefortheplayerdefrandom_place(board,player):

selection=possibilities(board)current_loc=random.choice(selection)board[current_loc]=playerreturn(board)

#Checkswhethertheplayerhasthree#oftheirmarksinahorizontalrowdefrow_win(board,player):

forxinrange(len(board)):win=True

foryinrange(len(board)):

ifboard[x,y]!=player:win=Falsecontinue

ifwin==True:

return(win)

return(win)

#Checkswhethertheplayerhasthree#oftheirmarksinaverticalrow

defcol_win(board,player):

forxinrange(len(board)):win=True

foryinrange(len(board)):

ifboard[y][x]!=player:win=Falsecontinue

ifwin==True:

return(win)

return(win)

#Checkswhethertheplayerhasthree#oftheirmarksinadiagonalrow

defdiag_win(board,player):win=True

y=0

forxinrange(len(board)):

ifboard[x,x]!=player:win=False

ifwin:

returnwin

win=Trueifwin:

forxinrange(len(board)):y=len(board)-1-x

ifboard[x,y]!=player:win=False

returnwin

#Evaluateswhetherthereis#awinneroratie

defevaluate(board):

winner=0

forplayerin[1,2]:

if(row_win(board,player)or

col_win(board,player)ordiag_win(board,player)):

winner=player

ifnp.all(board!=0)andwinner==0:winner=-1

returnwinner

#Mainfunctiontostartthegamedefplay_game():

board,winner,counter=create_board(),0,1print(board)

sleep(2)

whilewinner==0:

forplayerin[1,2]:

board=random_place(board,player)print("Boardafter"+str(counter)+"move")print(board)

sleep(2)counter+=1

winner=evaluate(board)ifwinner!=0:

break

return(winner)

#DriverCode

print("Winneris:"+str(play_game()))

Output:-

[[0

0

0]

[0

0

0]

[0

0

0]]

Boardafter1move

[[0

0

0]

[0

0

0]

[1

0

0]]

Boardafter2move

[[0

0

0]

[0

2

0]

[1

0

0]]

Boardafter3move

[[0

1

0]

[0

2

0]

[1

0

0]]

Boardafter4move

[[0

1

0]

[2

2

0]

[1

0

0]]

Boardafter5move

[[1

1

0]

[2

2

0]

[1

0

0]]

Boardafter6move

[[1

1

0]

[2

2

0]

[1

2

0]]

Boardafter7move

[[1

1

0]

[2

2

0]

[1

2

1]]

Boardafter8move[[110]

[222]

[121]]

Winneris:2

EXPERIMENT4

#WriteaProgramtoImplement8-PuzzleproblemusingPython.

classSolution:

defsolve(self,board):

dict={}

flatten=[]

foriinrange(len(board)):

flatten+=board[i]

flatten=tuple(flatten)

dict[flatten]=0

ifflatten==(0,1,2,3,4,5,6,7,8):

return0

returnself.get_paths(dict)

defget_paths(self,dict):

cnt=0

whileTrue:

current_nodes=[xforxindictifdict[x]==cnt]

iflen(current_nodes)==0:

return-1

fornodeincurrent_nodes:

next_moves=self.find_next(node)

formoveinnext_moves:

ifmovenotindict:

dict[move]=cnt+1

ifmove==(0,1,2,3,4,5,6,7,8):

returncnt+1

cnt+=1

deffind_next(self,node):

moves={

0:[1,3],

1:[0,2,4],

2:[1,5],

3:[0,4,6],

4:[1,3,5,7],

5:[2,4,8],

6:[3,7],

7:[4,6,8],

8:[5,7],

}

results=[]

pos_0=node.index(0)

formoveinmoves[pos_0]:

new_node=list(node)

new_node[move],new_node[pos_0]=new_node[pos_0],new_node[move]

results.append(tuple(new_node))

returnresults

ob=Solution()

matrix=[

[3,1,2],

[4,7,5],

[6,8,0]

]

print(ob.solve(matrix))

Output:-

4

EXPERIMENT5

##WriteaProgramtoImplementWater-JugproblemusingPython.

#Thisfunctionisusedtoinitializethe

#dictionaryelementswithadefaultvalue.fromcollectionsimportdefaultdict

#jug1andjug2containthevaluejug1,jug2,aim=4,3,2

#Initializedictionarywith#defaultvalueasfalse.

visited=defaultdict(lambda:False)defwaterJugSolver(amt1,amt2):

.

if(amt1==aimandamt2==0)or(amt2==aimandamt1==0):

print(amt1,amt2)returnTrue

ifvisited[(amt1,amt2)]==False:print(amt1,amt2)

visited[(amt1,amt2)]=Truereturn(waterJugSolver(0,amt2)or

waterJugSolver(amt1,0)orwaterJugSolver(jug1,amt2)orwaterJugSolver(amt1,jug2)orwaterJugSolver(amt1+min(amt2,(jug1-amt1)),amt2-min(amt2,(jug1-amt1)))orwaterJugSolver(amt1-min(amt1,(jug2-amt2)),amt2+min(amt1,(jug2-amt2))))

else:

returnFalse

print("Steps:")waterJugSolver(0,0)

Output:-

Steps:

0

0

4

0

4

3

0

3

3

0

3

3

42

02

EXPERIMENT6

#WriteaProgramtoImplementTravellingSalesmanProblemusingPython.

#Python3implementationoftheapproachV=4

answer=[]

#Functiontofindtheminimumweight#HamiltonianCycle

deftsp(graph,v,currPos,n,count,cost):

#Iflastnodeisreachedandithas#alinktothestartingnodei.e

#thesourcethenkeeptheminimum#valueoutofthetotalcostof

#traversaland"ans"

#Finallyreturntocheckfor#morepossiblevalues

if(count==nandgraph[currPos][0]):answer.append(cost+graph[currPos][0])return

#BACKTRACKINGSTEP

#Looptotraversetheadjacencylist

#ofcurrPosnodeandincreasingthecount#by1andcostbygraph[currPos][i]valueforiinrange(n):

if(v[i]==Falseandgraph[currPos][i]):

#Markasvisitedv[i]=True

tsp(graph,v,i,n,count+1,cost+graph[currPos][i])

#Markithnodeasunvisitedv[i]=False

#Drivercode

#nisthenumberofnodesi.e.Vif name ==' main ':

n=4

graph=[[0,10,15,20],

[10,0,35,25],

[15,35,0,30],

[20,25,30,0]]

#Booleanarraytocheckifanode#hasbeenvisitedornot

v=[Falseforiinrange(n)]

#Mark0thnodeasvisitedv[0]=True

#FindtheminimumweightHamiltonianCycletsp(graph,v,0,n,1,0)

#ansistheminimumweightHamiltonianCycleprint(min(answer))

Output:-

80

EXPERIMENT7

#WriteaProgramtoImplementTowerofHanoiusingPython.

#RecursivePythonfunctiontosolvethetowerofhanoidefTowerOfHanoi(n,source,destination,auxiliary):

ifn==1:

print"Movedisk1fromsource",source,"todestination",destinationreturn

TowerOfHanoi(n-1,source,auxiliary,destination)

print"Movedisk",n,"fromsource",source,"todestination",destinationTowerOfHanoi(n-1,auxiliary,destination,source)

#Drivercoden=4

TowerOfHanoi(n,'A','B','C')

#A,C,Barethenameofrods

Output:-

Move

disk

1

from

rod

A

to

rod

B

Move

disk

2

from

rod

A

to

rod

C

Move

disk

1

from

rod

B

to

rod

C

Move

disk

3

from

rod

A

to

rod

B

Move

disk

1

from

rod

C

to

rod

A

Move

disk

2

from

rod

C

to

rod

B

Move

disk

1

from

rod

A

to

rod

B

Move

disk

4

from

rod

A

to

rod

C

Move

disk

1

from

rod

B

to

rod

C

Move

disk

2

from

rod

B

to

rod

A

Move

disk

1

from

rod

C

to

rod

A

Move

disk

3

from

rod

B

to

rod

C

Move

disk

1

from

rod

A

to

rod

B

Move

disk

2

from

rod

A

to

rod

C

Move

disk

1

from

rod

B

to

rod

C

EXPERIMENT8

#WriteaProgramtoImplementMonkeyBananaProblemusingPython.

'''

Pythonprogrammingimplementationofmonkeypickingbananaproblem'''

#GlobalVariableii=0

defMonkey_go_box(x,y):globali

i=i+1

print('step:',i,'monkeyslave',x,'Goto'+y)

defMonkey_move_box(x,y):globali

i=i+1

print('step:',i,'monkeytaketheboxfrom',x,'deliverto'+y)

defMonkey_on_box():globali

i=i+1

print('step:',i,'Monkeyclimbsupthebox')

defMonkey_get_banana():globali

i=i+1

print('step:',i,'Monkeypickedabanana')

importsys

#Readtheinputoperatingparameters,codeIn=sys.stdin.read()codeInList=codeIn.split()

#Theoperatingparametersindicatethelocationsofmonkey,banana,andboxrespectively.

monkey=codeInList[0]banana=codeInList[1]box=codeInList[2]

print('Thestepsareasfollows:')

#PleaseusetheleaststepstocompletethemonkeypickingbananataskMonkey_go_box(monkey,box)

Monkey_move_box(box,banana)Monkey_on_box()Monkey_get_banana()

EXPERIMENT9

#WriteaProgramtoImplementAlpha-BetaPruningusingPython.

#workingofAlpha-BetaPruning

#InitialvaluesofAplhaandBetaMAX,MIN=1000,-1000

#Returnsoptimalvalueforcurrentplayer#(Initiallycalledforrootandmaximizer)

defminimax(depth,nodeIndex,maximizingPlayer,

values,alpha,beta):

#Terminatingcondition.i.e#leafnodeisreached

ifdepth==3:

returnvalues[nodeIndex]ifmaximizingPlayer:

best=MIN

#Recurforleftandrightchildrenforiinrange(0,2):

val=minimax(depth+1,nodeIndex*2+i,

False,values,alpha,beta)best=max(best,val)

alpha=max(alpha,best)

#AlphaBetaPruningifbeta<=alpha:

break

returnbest

else:

best=MAX

#Recurforleftand#rightchildren

foriinrange(0,2):

val=minimax(depth+