def __initUI(self):
self.parent.title("AI: Sudoku Solver")
self.pack(fill=BOTH)
self.canvas = Canvas(self, width=WIDTH, height=HEIGHT + 10)
self.easy_problem = Problem(self.canvas, 0, DELAY, random.randint(0, 1), setting = "easy")
self.hard_problem = Problem(self.canvas, 0, DELAY, random.randint(0, 1), setting = "hard")
self.problem = None # Set this by click button
# Initialize each cell in the puzzle
for i in range(1, 10):
for j in range(1, 10):
self.item = self.canvas.create_text(
MARGIN + (j - 1) * SIDE + SIDE / 2, MARGIN + (i - 1) * SIDE + SIDE / 2,
text='', tags="numbers", fill="black", font=("Helvetica", 12)
)
self.item = self.canvas.create_text(40, 490, text='Count :', fill="black", font=("Helvetica", 13))
self.item = self.canvas.create_text(95, 490, text='', fill="black", font=("Helvetica", 13))
self.item = self.canvas.create_text(170, 490, text='Average :', fill="black", font=("Helvetica", 13))
self.item = self.canvas.create_text(225, 490, text='',fill="black", font=("Helvetica", 13))
self.item = self.canvas.create_text(320, 490, text='Ranking :',fill="black", font=("Helvetica", 13))
self.item = self.canvas.create_text(370, 490, text='', fill="black", font=("Helvetica", 13))
self.item = self.canvas.create_text(420, 490, text='Total :', fill="black", font=("Helvetica", 13))
self.item = self.canvas.create_text(460, 490, text='', fill="black", font=("Helvetica", 13))
self.canvas.pack(fill=BOTH, side=TOP)
self.start_button1 = Button(self, text="__Hard__", command=self.__start_hard_solver)
self.start_button2 = Button(self, text="__Easy__", command=self.__start_easy_solver)
self.start_button2.pack(side=LEFT)
self.start_button1.pack(side=RIGHT)
#self.start_button2.config(state="disabled")
self.__draw_grid()
def __init__(self, sizeOfParticle):
self._initialGraph = Problem("in.txt").getGraph()
# self._initialVertices = Problem("in.txt").getVertices()
self._initialDictionary = Problem("in.txt").getDictionary()
self._sizeOfParticle = sizeOfParticle
self._position = self.getRandom()
self._fitness = None
self.evaluate()
self.velocity = [0 for x in range(sizeOfParticle)]
self._bestPosition = self._position.copy()
self._bestFitness = self._fitness
def random_restart_hill_climbing(n=100):
current_state = hill_climbing(Problem().randomize_graph())
best_val = current_state.value()
visited = current_state.visited
explored = current_state.explored
for i in range(0, n - 1):
tmp = hill_climbing(Problem().randomize_graph())
visited += tmp.visited
explored += tmp.explored
if tmp.value() < best_val:
current_state = tmp
best_val = current_state.value()
current_state.set_explored(explored)
current_state.set_visited(visited)
return current_state
def main():
problem = Problem("temperature.in", "humidity.in", "rules.in")
c = Controller(problem)
c.solveFuzzy()
c.solveFuzzy()
c.solveFuzzy()
c.solveFuzzy()
def Solve(self, problem):
self.problem = Problem(problem)
# self.print_problem_info()
if self.problem.problemType == "2x2":
return [1., 1., 1., 1., 1., 1.]
if self.problem.problemType == "3x3" and self.problem.hasVerbal:
solverE = SolverE(self.problem)
anAnswer = solverE.solve()
if solverE.total_count == 0:
solverD = SolverD(self.problem)
myAnswer = solverD.solve()
else:
myAnswer = anAnswer
if self.problem.problemType == "3x3" and not self.problem.hasVerbal:
if "D-" in self.problem.name:
solverD = SolverD(self.problem)
myAnswer = solverD.solve()
elif "E-" in self.problem.name:
solverE = SolverE(self.problem)
myAnswer = solverE.solve()
else:
solverE = SolverE(self.problem)
anAnswer = solverE.solve()
if solverE.total_count == 0:
solverD = SolverD(self.problem)
myAnswer = solverD.solve()
else:
myAnswer = anAnswer
# self.test_correct_answer(myAnswer)
return myAnswer
def find_idastar_route(source, target):
def g(node):
return node.path_cost
def h(node):
junction = roads[node.state]
target = roads[goal.state]
x = compute_distance(junction.lat, junction.lon, target.lat,
target.lon) / 110
return x
roads = load()
#roads = load('israel.csv',0,50)
start = Node(roads[source])
goal = Node(roads[target])
p = Problem(start, goal, roads)
limit_cost = h(start)
path = [start.state]
while (True):
import time
t = time.time
next = ida_star(path, p, start, limit_cost, f=lambda n: g(n) + h(n))
if next == -1:
print(t - time.time)
return path[::-1]
if next == math.inf:
return None
limit_cost = next
def main():
filename = "in.txt"
p = Problem(filename)
graph, vertices = p.readFromFile()
# PARAMETERS:
noIteratii = 10
# number of particles
noParticles = 10
# individual size
dimParticle = len(graph)
# specific parameters for PSO
w = 1.0
c1 = 1.0
c2 = 2.5
sizeOfNeighborhood = 3
P = population(noParticles, dimParticle)
# we establish the particles' neighbors
neighborhoods = selectNeighbors(P, sizeOfNeighborhood)
for i in range(noIteratii):
P = iteration(P, neighborhoods, c1, c2, w / (i + 1))
best = 0
for i in range(1, len(P)):
if P[i].getFitness() < P[best].getFitness():
best = i
fitnessOptim = P[best].getFitness()
individualOptim = P[best].getPosition()
print("fitnessOptim " + str(fitnessOptim))
print("individualOptim " + str(individualOptim))
def parseFile(self):
matrices = []
for i, line in enumerate(self):
line = line.rstrip()
if i == 0:
problemTitle = line
elif i == 1:
problemSize = line
elif i == 2:
correctAnswer = line
else:
if not line.startswith("\t"):
#this is a matrix
newMatrix = Matrix(line)
matrices.append(newMatrix)
elif not line.startswith("\t\t"):
#this is an object
line = line.strip()
newObject = Object(line)
newMatrix.objects[line] = newObject
else:
#this is an attribute (key-value pair)
line = line.strip()
keyValue = line.split(":")
newObject.attributes.update({keyValue[0]: keyValue[1]})
problem = Problem(problemTitle, problemSize, correctAnswer, matrices)
return problem
def search(iterations, population, low_bound, high_bound, max_vel, C1, C2,
topology, pso_type):
problem = Problem()
fitness = []
pop = create_population(population)
collection = list(enumerate(pop, start=0))
gbest = update_global_best(pop)
lbest = gbest
fbest = gbest
for ite in xrange(iterations):
for i, particle in collection:
if topology == "local":
lbest = update_local_best(pop, i, lbest)
update_velocity(particle, lbest, max_vel, C1, C2, ite,
pso_type)
elif topology == "focal":
fbest = update_local_best(pop, i, fbest)
update_velocity(particle, fbest, max_vel, C1, C2, ite,
pso_type)
else:
update_velocity(particle, gbest, max_vel, C1, C2, ite,
pso_type)
update_position(particle, low_bound, high_bound)
particle.cost = problem.sphere(particle.position)
update_personal_best(particle)
gbest = update_global_best(pop, gbest)
print "Iteration: ", ite, "Fitness: ", gbest.cost
fitness.append(gbest.cost)
return gbest, fitness
def main():
D = 20
problem = Problem('problem.txt')
clusters = Clustering(problem, D)
clusters.clustering()
# print(clusters.cluster)
aif = ArcIndexedFormulation({
"N": [0, 1, 2, 3, 4],
"V": [1, 2, 3, 4],
'k': [5, 5, 5, 5],
'c': [10, 10, 10, 10, 10],
's0': [5, 5, 5, 5, 5],
't': [[1, 2, 3, 4, 5], [1, 2, 3, 4, 5], [1, 2, 3, 4, 5],
[1, 2, 3, 4, 5], [1, 2, 3, 4, 5]],
'alpha':
0.3,
'T':
100,
'U':
1,
'L':
1,
'f':
problem.f
})
aif.solve()
def __init__(self):
self.__problem = Problem()
self.__dimPopulation = 0
self.__noOfIterations = 0
self.readFromFile()
self.__population = Population(self.__dimPopulation)
self.__best = []
def main():
"""
Main method, where the magic is done. This method creates and initializes the original state.
Then, applying the selected search algorithm, it calculates and it writes the correct solution.
:return:
"""
parser = argparse.ArgumentParser()
parser.add_argument('-a',
'--algorithm',
required=True,
type=str,
default='DFS',
help='Set the search algorithm desired.')
parser.add_argument('-d',
'--depth',
default=9,
type=int,
help='Set the maximum depth.')
parser.add_argument('-i',
'--increase',
default=1,
type=int,
help='Set the increase in each iteration.')
parser.add_argument(
'-r',
'--random',
default=False,
type=bool,
help='Initial state configuration is randomly generated.')
parser.add_argument('-f',
'--file',
default='../terrain.txt',
type=str,
help='Route to load your initial state configuration.')
parser.add_argument('-o',
'--output',
default='successors.txt',
type=str,
help='File to write the solution.')
args = parser.parse_args()
terrain = State(0, 0, 0, 0, 0, 0, 0) # Initial state. Initialized at 0.
operations = Problem(0, 0, args.file, terrain)
if args.random: # Generate the terrain randomly
operations.generate_terrain(terrain)
else:
if operations.file_format_correct():
operations.read_file(terrain)
else:
print("File {} has not a valid format.".format(args.file))
exit(1)
# Search algorithm to calculate the solution
sol = Search_Algorithm().search(operations, args.algorithm, args.depth,
args.increase)
if sol is None:
print('No se ha encontrado una solución')
else:
operations.write_file(sol, args.output)
def main():
parser = argparse.ArgumentParser(
description='''The driver Script for Compilation''',
epilog=
"Usage >> ./Compiler.py -m current_domain.pddl -p current_problem.pddl -f plan_fragment"
+
" -t domain_templ.pdd -r prob_templ.pddl -s new_domain.pddl -q new_problem.pddl"
)
# Flags for the search
parser.add_argument('-m',
'--model',
type=str,
help="Domain file with real PDDL model of robot.",
required=True)
parser.add_argument('-p',
'--problem',
type=str,
help="Problem file for robot.",
required=True)
parser.add_argument('-t',
'--domain_templ',
type=str,
help="Template for domain file for robot.",
required=True)
parser.add_argument('-r',
'--prob_templ',
type=str,
help="Template for problem file for robot.",
required=True)
parser.add_argument('-s',
'--domain_dest',
type=str,
help="Destination for the new domain file for robot.",
required=True)
parser.add_argument('-q',
'--prob_dest',
type=str,
help="Destination for new problem file for robot.",
required=True)
parser.add_argument('-f',
'--plan_file',
type=str,
help="Plan file.",
required=True)
if not sys.argv[1:] or '-h' in sys.argv[1:]:
print parser.print_help()
sys.exit(1)
args = parser.parse_args()
# define problem object and run the required search
try:
pr_obj = Problem(args.model, args.problem, args.plan_file,
args.domain_templ, args.prob_templ, args.domain_dest,
args.prob_dest)
except Exception as e:
print("Exception: " + str(e))
def main():
c = CommandLine(sys.argv)
c.run()
problem = Problem(c.instance())
problem.processInstanceFiles()
problem.print()
def loadLevelPushButtonClicked(self):
levelPathText = self.levelPathLineEdit.text()
newProblem = Problem(
'/Users/so/Desktop/Y2S2/AI/Lab1 - UnblockMe/Levels/' +
levelPathText)
self._controller.setProblem(newProblem)
self.drawTable(newProblem.getInitialState())
def start(self):
filename = "in.txt"
probability = 0.01
populationSize = 50
noOfIterations = 1000
problem = Problem(filename)
A = problem.getA()
subsets = problem.getSubsets()
# print(A, subsets)
individSize = len(A)
individ = Individ(individSize, A, A, subsets)
population = Population(populationSize)
population.computePopulation(A, individSize, subsets)
algorithm = Algorithm(problem, population)
graded, fitnessOptim, individualOptim, avgfitness = algorithm.run(
noOfIterations, probability, individ)
print('Result:\n After %d iterations \n Fitness Optim: %d' %
(noOfIterations, fitnessOptim))
print(" Individual Optim:" + str(individualOptim))
meanValue, standardDeviation = algorithm.statistics()
print("Mean Value: " + str(meanValue))
print("Standard Deviation: " + str(standardDeviation))
algorithm.getPlot(avgfitness)
def check(self, input):
self.lbl_message.clear()
self.edit_input.clear()
self.problem.check(input)
if self.problem.result == "ValueError":
message = "Error: Bad input."
if self.problem.attempt > -1:
message += (" " * 5 + "Attempt " +
str(self.problem.attempt + 1) + "/" +
str(MAX_ATTEMPTS) + "." + " " * 5 +
"Previous answers: " +
", ".join(self.problem.previous_answers))
self.lbl_message.setText(message)
elif self.problem.result == "correct":
self.lbl_message.setText("Correct! Moving to next question.")
self.problem = Problem()
self.lbl_statement.setText(self.problem.statement)
elif self.problem.result == "incorrect":
if self.problem.attempt == MAX_ATTEMPTS - 1:
self.problem.pose()
self.lbl_statement.setText(self.problem.statement)
self.lbl_message.setText(
"Incorrect. All attempts used. Numbers changed.")
else:
self.lbl_message.setText(
"Incorrect." + " " * 5 + "Attempt " +
str(self.problem.attempt + 1) + "/" + str(MAX_ATTEMPTS) +
"." + " " * 5 + "Previous answers: " +
", ".join(self.problem.previous_answers))
def plotACO(self):
p = Problem()
controller = Controller(self.__nrOfIndividuals, p.getSize(),
self.__nrOfEvaluations)
fitnesses = []
for i in range(self.__nrOfRuns):
sol = controller.runAlgorithm()
permSolution = sol[0]
print(sol[1])
fitnesses.append(sol[1])
m = np.mean(fitnesses, axis=0)
std = np.std(fitnesses, axis=0)
means = []
stddev = []
for i in range(self.__nrOfRuns):
means.append(m)
stddev.append(std)
plt.plot(range(self.__nrOfRuns), means)
plt.plot(range(self.__nrOfRuns), stddev)
plt.plot(range(self.__nrOfRuns), fitnesses)
plt.show()
def play(self):
mapp = self.map.getMapState()
# generate problem to solve
problem = Problem(State(mapp))
# set problem
self.searchAlgorithm.setProblem(problem)
# calculate running time
start = time.time()
# solve problem
self.map.loadInfo("solving")
moves = self.searchAlgorithm.solve()
if moves != []: self.map.loadInfo("found")
else: self.map.loadInfo("notfound")
# stop time
stop = time.time()
# print some statistics
print "Thoi gian giai quyet : %d giay" % (stop - start)
print "So luong move la : %d" % len(moves)
self.map.loadTime(start)
for move in moves:
self.map.moveBlock(move.mapp)
self.map.loadMove()
self.map.move = 1
# notify that player have solve the problem
print "AI player done playing!"
def main():
theta = np.random.randn(6, 1)
p = Problem("database.txt")
#x = p.getX()
y = p.getY()
c = Controller(10, p)
#x_b = np.c_[np.ones((len(x), 1)), x]
'''
#theta, cost_history, theta_history = c.gradientDescent(theta, x_b)
theta, cost_history = c.stochasticGradientDescent(theta)
error = c.getError(theta)
print("Theta:")
print(theta[0][0])
print("Theta1:")
print(theta[1][0])
print("Theta2:")
print(theta[2][0])
print("Theta3:")
print(theta[3][0])
print("Theta4:")
print(theta[4][0])
print("Error:")
print(error)
'''
X = 2 * np.random.rand(100, 5)
#y = 4 +3 * X+np.random.randn(100,1)
print(X)
print("bine")
print("bine")
print("bine")
print(y)
def problems_list(URL):
'''
This functions takes a spoj problems page url, and returns a list of Problem instances.
'''
debug("Fetching html....")
html_data = urllib.urlopen(URL).read()
debug("Html fetched, prettifying results....")
soup = BeautifulSoup(html_data, 'html.parser')
table = soup.find('table', attrs={'class': 'problems'})
problems_list = table.find('tbody').findAll('tr')
debug("In the middle of parsing....")
problems = []
for problem in problems_list:
col_list = problem.findAll('td')
pid = col_list[0].string.strip()
plink = 'http://www.spoj.com' + col_list[1].find('a').get('href')
pname = col_list[1].find('a').string.strip()
try:
quality = col_list[2].find('span').find('strong').string.strip()
except AttributeError:
quality = 'undefined'
users = col_list[3].find('a').string.strip()
accuracy = col_list[4].find('a').string.strip()
instance = Problem(pid, pname, plink, quality, users, accuracy)
problems.append(instance)
debug("Done!")
return problems
def get_problem(prob):
details = SPOJScrapper.get_prob_desc(prob)
# print details
if details is None:
raise Exception("Problem code invalid")
desc = details[0]
category_link = details[1]
problem = Problem(prob, desc, category_link)
current_page = category_link
while True:
response = urlopen(current_page)
html = response.read()
soup = BeautifulSoup(html, 'html.parser')
prob_link = soup.find('a', href='/ranks/' + prob)
if prob_link is not None:
SPOJScrapper.set_points_and_solvers(problem, prob_link)
return problem
else:
next_element = SPOJScrapper.get_next_url(soup)
if next_element is None:
raise Exception("Couldn't find problem link")
current_page = URLutil.SPOJURL + SPOJScrapper.get_next_url(
soup)['href']
def main():
parser = argparse.ArgumentParser(
description='''Driver script for Projection-Aware Planning''',
epilog="Usage >> ./main.py -u 1")
parser.add_argument('-u',
'--usecase',
type=int,
help="ID of the Use Case.")
parser.add_argument('-d',
'--domain',
type=str,
help="(path to) domain file.")
parser.add_argument('-p',
'--problem',
type=str,
help="(path to) problem file.")
parser.add_argument('-o',
'--hyps',
type=str,
help="(path to) hypothesis file.")
parser.add_argument('-r',
'--real_hyp',
type=str,
help="(path to) real hypothesis file.")
if not sys.argv[1:] or '-h' in sys.argv[1:]:
print parser.print_help()
sys.exit(1)
args = parser.parse_args()
if args.usecase == 1:
problem_instance = Problem(args.domain, args.problem)
print PAPP(problem_instance)
elif args.usecase == 2:
execution_instance = Exe(args.domain, args.problem, args.hyps,
args.real_hyp)
print execution_instance.getPlan()
print execution_instance.getProjection()
elif args.usecase == 3:
execution_instance = ExeHILP(args.domain, args.problem, args.hyps,
args.real_hyp)
print execution_instance.getPlan()
print execution_instance.getProjection()
elif args.usecase == 4:
raise NotImplementedError
else:
pass
def preIn():
prein = PreIn()
p = Problem()
tree = p.buildTree(prein.preorder.raw_data[0].split(','),
prein.inorder.raw_data[0].split(','))
prein.showResult = True
prein.traversal = tree.getTreeRepresentation(order='post')
return render_template('prein.html', form=prein)
def main():
problem = Problem()
controller = Controller()
ui = UI(controller)
problem.loadProblem()
controller.loadParameters(problem)
ui.run()
def new_population_production(populationSize):
population = []
for i in range(0, populationSize):
chromosome = Problem()
for node in chromosome.graph:
node.set_color(random.choice([0, 1, 2]))
population.append(chromosome)
return population
def postIn():
postin = PostIn()
p = Problem()
tree = p.buildTreeFromPostOrderAndInorder(
postin.postorder.raw_data[0].split(','),
postin.inorder.raw_data[0].split(','))
postin.showResult = True
postin.traversal = tree.getTreeRepresentation(order='pre')
return render_template('postin.html', form=postin)
def __init__(self, problemFile, paramFile, toBe=False):
self._problem = Problem(problemFile)
self._dimParticle = len(self._problem.getVertices())
self._noPopulation, self._sizeOfNeighborhood, self._w, self._c1, self._c2 = 0, 0, 0, 0, 0
self.loadParameters(paramFile)
self._population = Swarm(self._noPopulation, self._dimParticle,
self._problem)
self._neighborhoods = self.selectNeighbors()
self._toBeDrawn = toBe
def main():
problem = Problem("../json/x4cube.json")
fringe = Frontier()
print("Starting test... ")
start = time.time()
stress_test(problem, fringe)
print("Total time: %.11f" % (time.time() - start))
print("\nStress test has ended.")
def __init__(self, coin_set=None, max_chances=100):
if not Problem.singleton_problem:
Problem(coin_set)
self.__population_size = 10
self.population = self.__createInitialPopulation()
self.best_fit = None
self.__current_generation = 1
self.max_chances = max_chances
self.__same_best_chances = self.max_chances
