def solve():
sets = [] # The variable 'sets' stores multiple problem sets.
# Each problem set comes from a different folder in /Problems/
# Additional sets of problems will be used when grading projects.
# You may also write your own problems.
r = open(os.path.join(
"Problems",
"ProblemSetList.txt")) # ProblemSetList.txt lists the sets to solve.
line = getNextLine(
r) # Sets will be solved in the order they appear in the file.
while not line == "": # You may modify ProblemSetList.txt for design and debugging.
sets.append(
ProblemSet(line)
) # We will use a fresh copy of all problem sets when grading.
line = getNextLine(
r) # We will also use some problem sets not given in advance.
# Initializing problem-solving agent from Agent.java
agent = Agent(
) # Your agent will be initialized with its default constructor.
# You may modify the default constructor in Agent.java
# Running agent against selected problem
for set in sets:
if set.name == "Basic Problems D":
for problem in set.problems: # Your agent will solve one problem at a time.
if problem.name == "Basic Problem D-06":
print('\n', problem.name, problem.problemType, problem.problemSetName, \
problem.hasVisual, problem.hasVerbal)
answer = agent.Solve(problem)
print('Final answer:', str(answer))
r.close()
def solve():
sets=[] # The variable 'sets' stores multiple problem sets.
# Each problem set comes from a different folder in /Problems/
# Additional sets of problems will be used when grading projects.
# You may also write your own problems.
r = open(os.path.join("Problems","ProblemSetList.txt")) # ProblemSetList.txt lists the sets to solve.
line = getNextLine(r) # Sets will be solved in the order they appear in the file.
while not line=="": # You may modify ProblemSetList.txt for design and debugging.
sets.append(ProblemSet(line)) # We will use a fresh copy of all problem sets when grading.
line=getNextLine(r) # We will also use some problem sets not given in advance.
# Initializing problem-solving agent from Agent.java
agent=Agent() # Your agent will be initialized with its default constructor.
# You may modify the default constructor in Agent.java
# Running agent against each problem set
with open("AgentAnswers.csv","w") as results: # Results will be written to ProblemResults.csv.
# Note that each run of the program will overwrite the previous results.
# Do not write anything else to ProblemResults.txt during execution of the program.
results.write("ProblemSet,RavensProblem,Agent's Answer\n")
for set in sets:
for problem in set.problems: # Your agent will solve one problem at a time.
#try:
answer = agent.Solve(problem) # The problem will be passed to your agent as a RavensProblem object as a parameter to the Solve method
# Your agent should return its answer at the conclusion of the execution of Solve.
results.write("%s,%s,%d\n" % (set.name, problem.name, answer))
print(set.name, problem.name, answer,'\n')
r.close()
def main():
sets=[] # The variable 'sets' stores multiple problem sets.
# Each problem set comes from a different folder in /Problems/
# Additional sets of problems will be used when grading projects.
# You may also write your own problems.
for file in os.listdir("Problems"): # One problem set per folder in /Problems/
newSet = ProblemSet(file) # Each problem set is named after the folder in /Problems/
sets.append(newSet)
for problem in os.listdir("Problems" + os.sep + file): # Each file in the problem set folder becomes a problem in that set.
f = open("Problems" + os.sep + file + os.sep + problem) # Make sure to add only problem files to subfolders of /Problems/
newSet.addProblem(f)
# Initializing problem-solving agent from Agent.java
agent=Agent() # Your agent will be initialized with its default constructor.
# You may modify the default constructor in Agent.java
# Running agent against each problem set
results=open("Results.txt","w") # Results will be written to Results.txt.
# Note that each run of the program will overwrite the previous results.
# Do not write anything else to Results.txt during execution of the program.
for set in sets:
results.write("%s\n" % set.getName()) # Your agent will solve one problem set at a time.
results.write("%s\n" % "-----------") # Problem sets will be individually categorized in the results file.
for problem in set.getProblems(): # Your agent will solve one problem at a time.
problem.setAnswerReceived(agent.Solve(problem)) # The problem will be passed to your agent as a RavensProblem object as a parameter to the Solve method
# Your agent should return its answer at the conclusion of the execution of Solve.
# Note that if your agent makes use of RavensProblem.check to check its answer, the answer passed to check() will be used.
# Your agent cannot change its answer once it has checked its answer.
result=problem.getName() + ": " + problem.getGivenAnswer() + " " + problem.getCorrect() + " (" + problem.correctAnswer + ")"
results.write("%s\n" % result)
results.write("\n")
def main():
sets = [] # The variable 'sets' stores multiple problem sets.
# Each problem set comes from a different folder in /Problems/
# Additional sets of problems will be used when grading projects.
# You may also write your own problems.
r = open(
"Problems" + os.sep +
"ProblemSetList.txt") # ProblemSetList.txt lists the sets to solve.
line = getNextLine(
r) # Sets will be solved in the order they appear in the file.
while not line == "": # You may modify ProblemSetList.txt for design and debugging.
sets.append(
ProblemSet(line)
) # We will use a fresh copy of all problem sets when grading.
line = getNextLine(
r) # We will also use some problem sets not given in advance.
# Initializing problem-solving agent from Agent.java
agent = Agent(
) # Your agent will be initialized with its default constructor.
# You may modify the default constructor in Agent.java
# Running agent against each problem set
results = open("ProblemResults.csv",
"w") # Results will be written to ProblemResults.csv.
# Note that each run of the program will overwrite the previous results.
# Do not write anything else to ProblemResults.txt during execution of the program.
setResults = open(
"SetResults.csv",
"w") # Set-level summaries will be written to SetResults.csv.
results.write("Problem,Agent's Answer,Correct?,Correct Answer\n")
setResults.write("Set,Correct,Incorrect,Skipped\n")
for set in sets:
for problem in set.problems: # Your agent will solve one problem at a time.
#try:
problem.setAnswerReceived(
agent.Solve(problem)
) # The problem will be passed to your agent as a RavensProblem object as a parameter to the Solve method
# Your agent should return its answer at the conclusion of the execution of Solve.
# Note that if your agent makes use of RavensProblem.check to check its answer, the answer passed to check() will be used.
# Your agent cannot change its answer once it has checked its answer.
result = problem.name + "," + str(
problem.givenAnswer) + "," + problem.getCorrect() + "," + str(
problem.correctAnswer)
results.write("%s\n" % result)
#except:
# print("Error encountered in " + problem.name + ":")
# print(sys.exc_info()[0])
# result=problem.name + "," + str(problem.givenAnswer) + ",Error," + str(problem.correctAnswer)
# results.write("%s\n" % result)
setResult = set.name + "," + str(set.getTotal("Correct")) + "," + str(
set.getTotal("Incorrect")) + "," + str(set.getTotal("Skipped"))
setResults.write("%s\n" % setResult)
results.close()
setResults.close()
def solve():
sets = []
r = open(os.path.join("Problems", "ProblemSetList.txt"))
line = getNextLine(r)
while not line == "":
sets.append(ProblemSet(line))
line = getNextLine(r)
agent = Agent()
with open("AgentAnswers.csv", "w") as results:
results.write("ProblemSet,RavensProblem,Agent's Answer\n")
for set in sets:
for problem in set.problems:
answer = agent.Solve(problem)
results.write("%s,%s,%d\n" % (set.name, problem.name, answer))
r.close()
def main():
sets=[] # The variable 'sets' stores multiple problem sets.
# Each problem set comes from a different folder in /Problems/
# Additional sets of problems will be used when grading projects.
r = open("Problems" + os.sep + "ProblemSetList.txt") # ProblemSetList.txt lists the sets to solve.
line = getNextLine(r) # Sets will be solved in the order they appear in the file.
while not line=="":
sets.append(ProblemSet(line))
line=getNextLine(r)
# Initializing problem-solving agent from Agent.java
agent=Agent()
# Running agent against each problem set
results=open("ProblemResults.csv","w")
setResults=open("SetResults.csv","w") # Set-level summaries will be written to SetResults.csv.
results.write("Problem,Agent's Answer,Correct?,Correct Answer\n")
setResults.write("Set,Correct,Incorrect,Skipped\n")
for set in sets:
for problem in set.problems: # Your agent will solve one problem at a time.
#try:
problem.setAnswerReceived(agent.Solve(problem))
result=problem.name + "," + str(problem.givenAnswer) + "," + problem.getCorrect() + "," + str(problem.correctAnswer)
results.write("%s\n" % result)
#except:
# print("Error encountered in " + problem.name + ":")
# print(sys.exc_info()[0])
# result=problem.name + "," + str(problem.givenAnswer) + ",Error," + str(problem.correctAnswer)
# results.write("%s\n" % result)
setResult=set.name + "," + str(set.getTotal("Correct")) + "," + str(set.getTotal("Incorrect")) + "," + str(set.getTotal("Skipped"))
setResults.write("%s\n" % setResult)
results.close()
setResults.close()
def main():
sets = [] # The variable 'sets' stores multiple problem sets.
# Each problem set comes from a different folder in /Problems/
# Additional sets of problems will be used when grading projects.
# You may also write your own problems.
r = open(
"Problems" + os.sep +
"ProblemSetList.txt") # ProblemSetList.txt lists the sets to solve.
line = getNextLine(
r) # Sets will be solved in the order they appear in the file.
while not line == "": # You may modify ProblemSetList.txt for design and debugging.
sets.append(
ProblemSet(line)
) # We will use a fresh copy of all problem sets when grading.
line = getNextLine(
r) # We will also use some problem sets not given in advance.
# Initializing problem-solving agent from Agent.java
agent = Agent(
) # Your agent will be initialized with its default constructor.
# You may modify the default constructor in Agent.java
# Running agent against each problem set
results = open("ProblemResults.csv",
"w") # Results will be written to ProblemResults.csv.
# Note that each run of the program will overwrite the previous results.
# Do not write anything else to ProblemResults.txt during execution of the program.
setResults = open(
"SetResults.csv",
"w") # Set-level summaries will be written to SetResults.csv.
results.write("Problem,Correct Confidence,Score,Time\n")
setResults.write("Set,Sum Correct Confidence,Sum Score\n")
for set in sets:
sum_correct_confidence = 0
sum_score = 0
for problem in set.problems: # Your agent will solve one problem at a time.
try:
start = time.time()
problem.setAnswerReceived(
agent.Solve(problem)
) # The problem will be passed to your agent as a RavensProblem object as a parameter to the Solve method
# Your agent should return its answer at the conclusion of the execution of Solve.
# Note that if your agent makes use of RavensProblem.check to check its answer, the answer passed to check() will be used.
# Your agent cannot change its answer once it has checked its answer.
end = time.time()
timeUsed = (end - start) * 1000
correct_confidence = 0
score = 0
if type(problem.givenAnswer) is list:
answer = problem.givenAnswer
if len(answer) >= problem.correctAnswer:
answer = [max(i, 0) for i in answer]
if sum(answer) > 0.01:
sum_answer = float(sum(answer))
answer = [i / sum_answer for i in answer]
correct_confidence = answer[problem.correctAnswer - 1]
score = 1 - (1 - correct_confidence)**2
sum_correct_confidence += correct_confidence
sum_score += score
result = problem.name + "," + str(
correct_confidence) + "," + str(score) + "," + str(
timeUsed)
results.write("%s\n" % result)
except:
print("Error encountered in " + problem.name + ":")
print(traceback.format_exc())
result = problem.name + ",Error,Error, "
results.write("%s\n" % result)
setResult = set.name + "," + str(sum_correct_confidence) + "," + str(
sum_score)
setResults.write("%s\n" % setResult)
results.close()
setResults.close()
from Agent import Agent
from ProblemSet import ProblemSet
import logging
import problem_utils
logging.basicConfig()
LOGGER = logging.getLogger(__name__)
LOGGER.setLevel(logging.DEBUG)
agent = Agent()
n_correct = 0
n_total = len(ProblemSet("Basic Problems B").problems)
for p in ProblemSet("Basic Problems B").problems:
LOGGER.info('=================================')
LOGGER.info('Solving problem {}'.format(p.name))
if problem_utils.is_problem2x2(p):
source = p.figures['A']
destination = p.figures['B']
guess = agent.Solve(p)
answer = p.checkAnswer(guess)
if guess == answer:
LOGGER.info('{}++++++++++++Correct+++++++++++++'.format(p.name))
n_correct += 1
else:
LOGGER.error('Wrong')
else:
print 'Not 2x2 problem'
print('Total correct answers {} out of {}'.format(n_correct, n_total))
def main():
parser = argparse.ArgumentParser(
description='Filters for what problems to solve')
parser.add_argument(
'--problem_sets',
type=str,
choices=['Basic', 'Challenge', 'Classmates', 'Unordered', 'Test'],
nargs='*')
parser.add_argument('--problems', type=int, nargs='*')
parser.add_argument('--interactive', type=bool, default=False)
args = parser.parse_args()
sets = [] # The variable 'sets' stores multiple problem sets.
# Each problem set comes from a different folder in /Problems/
# Additional sets of problems will be used when grading projects.
# You may also write your own problems.
for file in os.listdir(
"Problems"): # One problem set per folder in /Problems/
if file.startswith('.'):
continue
newSet = ProblemSet(
file) # Each problem set is named after the folder in /Problems/
sets.append(newSet)
for problem in os.listdir(
"Problems" + os.sep + file
): # Each file in the problem set folder becomes a problem in that set.
if problem.startswith('.'):
continue
f = open(
"Problems" + os.sep + file + os.sep + problem
) # Make sure to add only problem files to subfolders of /Problems/
newSet.addProblem(f)
# Initializing problem-solving agent from Agent.java
agent = Agent(
) # Your agent will be initialized with its default constructor.
# You may modify the default constructor in Agent.java
# Running agent against each problem set
results = open("Results.txt",
"w") # Results will be written to Results.txt.
# Note that each run of the program will overwrite the previous results.
# Do not write anything else to Results.txt during execution of the program.
for set in sets:
if args.problem_sets and set.getName().split(
)[1] not in args.problem_sets:
continue
results.write(
"%s\n" %
set.getName()) # Your agent will solve one problem set at a time.
results.write(
"%s\n" % "-----------"
) # Problem sets will be individually categorized in the results file.
print set.getName()
correct = 0
for problem in set.getProblems(
): # Your agent will solve one problem at a time.
if args.problems and int(
problem.getName().split()[3]) not in args.problems:
continue
problem.setAnswerReceived(
agent.Solve(problem)
) # The problem will be passed to your agent as a RavensProblem object as a parameter to the Solve method
# Your agent should return its answer at the conclusion of the execution of Solve.
# Note that if your agent makes use of RavensProblem.check to check its answer, the answer passed to check() will be used.
# Your agent cannot change its answer once it has checked its answer.
result = problem.getName() + ": " + problem.getGivenAnswer(
) + " " + problem.getCorrect() + " (" + problem.correctAnswer + ")"
if problem.getCorrect() == 'Correct':
correct += 1
results.write("%s\n" % result)
results.write("\n")
print "%d correct" % correct
class TestUM(unittest.TestCase):
def setUp(self):
with warnings.catch_warnings():
warnings.simplefilter("ignore")
#print("=====Setup===== \n")
# taken from RavensProject.py
self.sets = []
r = open(os.path.join("Problems", "ProblemSetList.txt")
) # ProblemSetList.txt lists the sets to solve.
line = getNextLine(
r) # Sets will be solved in the order they appear in the file.
while not line == "": # You may modify ProblemSetList.txt for design and debugging.
self.sets.append(
ProblemSet(line)
) # We will use a fresh copy of all problem sets when grading.
line = getNextLine(r)
r.close()
self.agent = Agent()
self.problemDict = {}
for set in self.sets:
for problem in set.problems:
self.problemDict[problem.name] = problem
#print("=================================")
#OR Gate
def testE01(self):
print("===================E01")
problem = self.problemDict["Basic Problem E-01"]
self.assertEqual(1, self.agent.Solve(problem))
def testE02(self):
print("===================E02")
problem = self.problemDict["Basic Problem E-02"]
self.assertEqual(7, self.agent.Solve(problem))
def testE03(self):
print("===================E03")
problem = self.problemDict["Basic Problem E-03"]
self.assertEqual(2, self.agent.Solve(problem))
#AND Gate
def testE10(self):
print("===================E10")
problem = self.problemDict["Basic Problem E-10"]
self.assertEqual(8, self.agent.Solve(problem))
def testE11(self):
print("===================E11")
problem = self.problemDict["Basic Problem E-11"]
self.assertEqual(5, self.agent.Solve(problem))
#XOR Gate
def testE05(self):
print("===================E05")
problem = self.problemDict["Basic Problem E-05"]
self.assertEqual(5, self.agent.Solve(problem))
def testE07(self):
print("===================E07")
problem = self.problemDict["Basic Problem E-07"]
self.assertEqual(3, self.agent.Solve(problem))
def testE08(self):
print("===================E08")
problem = self.problemDict["Basic Problem E-08"]
self.assertEqual(1, self.agent.Solve(problem))
def tearDown(self):
pass
class TestUM(unittest.TestCase):
def setUp(self):
#print("=====Setup===== \n")
self.Basic_B_Score = 0
# taken from RavensProject.py
self.sets = []
r = open(os.path.join("Problems", "ProblemSetList.txt")
) # ProblemSetList.txt lists the sets to solve.
line = getNextLine(
r) # Sets will be solved in the order they appear in the file.
while not line == "": # You may modify ProblemSetList.txt for design and debugging.
self.sets.append(
ProblemSet(line)
) # We will use a fresh copy of all problem sets when grading.
line = getNextLine(r)
r.close()
self.agent = Agent()
self.problemDict = {}
for set in self.sets:
for problem in set.problems:
self.problemDict[problem.name] = problem
#print("=================================")
"""
def test_guessReflection(self):
# Quadrant 1 interior
angles = ("45","135") #B4
self.assertEqual(image_processing.guessRelection(angles),"vertical")
angles = ("45","315") #B4
self.assertEqual(image_processing.guessRelection(angles),"horizontal")
# Quadrant 2 interior
angles = ("135","225") #B4
self.assertEqual(image_processing.guessRelection(angles),"horizontal")
angles = ("135","45")
self.assertEqual(image_processing.guessRelection(angles),"vertical")
# Quadrant 3 interior
angles = ("225","135")
self.assertEqual(image_processing.guessRelection(angles),"horizontal")
angles = ("225","315")
self.assertEqual(image_processing.guessRelection(angles),"vertical")
# Quadrant 4 interior
angles = ("315","45")
self.assertEqual(image_processing.guessRelection(angles),"horizontal")
angles = ("315","225")
self.assertEqual(image_processing.guessRelection(angles),"vertical")
# Quadrant 1 corner
angles = ("90","180") #B6
self.assertEqual(image_processing.guessRelection(angles),"vertical")
angles = ("90","0")
self.assertEqual(image_processing.guessRelection(angles),"horizontal")
# Quadrant 2 corner
angles = ("180","270")
self.assertEqual(image_processing.guessRelection(angles),"horizontal")
angles = ("180","90")
self.assertEqual(image_processing.guessRelection(angles),"vertical")
# Quadrant 3 corner
angles = ("270","0") #B3
self.assertEqual(image_processing.guessRelection(angles),"vertical")
angles = ("270","180") #B5
self.assertEqual(image_processing.guessRelection(angles),"horizontal")
# Quadrant 4 corner
angles = ("0","90")
self.assertEqual(image_processing.guessRelection(angles),"horizontal")
angles = ("0","270")
self.assertEqual(image_processing.guessRelection(angles),"vertical")
"""
def test_alignment_transform(self):
# horizontal flip
attributes = {}
attributes["alignment"] = "bottom-right"
transform = ("top-left", "top-right")
result = self.agent.alignmentTransform(attributes, transform)
self.assertTrue(result["alignment"], "bottom-left")
# symmetric horizontal flip
attributes = {}
attributes["alignment"] = "bottom-right"
transform = ("top-right", "top-left")
result = self.agent.alignmentTransform(attributes, transform)
self.assertTrue(result["alignment"], "bottom-left")
# vertical flip
attributes = {}
attributes["alignment"] = "top-left"
transform = ("top-left", "bottom-left")
result = self.agent.alignmentTransform(attributes, transform)
self.assertTrue(result["alignment"], "bottom-left")
# symmetric vertical flip
attributes = {}
attributes["alignment"] = "top-left"
transform = ("bottom-left", "top-left")
result = self.agent.alignmentTransform(attributes, transform)
self.assertTrue(result["alignment"], "bottom-left")
#double
attributes = {}
attributes["alignment"] = "top-right"
transform = ("bottom-left", "top-right")
result = self.agent.alignmentTransform(attributes, transform)
self.assertTrue(result["alignment"], "bottom-left")
#none
attributes = {}
attributes["alignment"] = "top-right"
transform = ("bottom-left", "bottom-left")
result = self.agent.alignmentTransform(attributes, transform)
self.assertTrue(result["alignment"], "top-right")
def test_agent_compareAttributes(self):
print("Validate agent's compareObjects method...")
print("Case where keys are the same...")
object1 = self.problemDict["Basic Problem B-01"].figures["A"].objects[
"a"]
object2 = self.problemDict["Basic Problem B-01"].figures["B"].objects[
"b"]
answer = {}
self.assertEqual(answer,
self.agent.compareAttributes(object1.attributes,
object2.attributes),
msg="Case where keys are the same")
print("Test different number of keys...")
object1 = self.problemDict["Basic Problem B-10"].figures["A"].objects[
"a"]
object2 = self.problemDict["Basic Problem B-10"].figures["A"].objects[
"b"]
answer = {"inside": ("b", None), "size": ("very large", "huge")}
self.assertEqual(answer,
self.agent.compareAttributes(object1.attributes,
object2.attributes),
msg="object 1 has less keys than object 2")
answer = {"inside": (None, "b"), "size": ("huge", "very large")}
self.assertEqual(answer,
self.agent.compareAttributes(object2.attributes,
object1.attributes),
msg="object 1 has more keys than object 2")
print("Test different sets of keys...")
object1 = self.problemDict["Basic Problem B-10"].figures["A"].objects[
"a"]
object2 = self.problemDict["Basic Problem B-04"].figures["A"].objects[
"a"]
answer = {
'angle': (None, '45'),
'fill': ('no', 'yes'),
'inside': ('b', None),
'shape': ('circle', 'pac-man')
}
self.assertEqual(
answer,
self.agent.compareAttributes(object1.attributes,
object2.attributes),
msg="object 1 and 2 have same number of keys, but different values"
)
object1 = {"attributes": {"shape": "circle", "fill": "yes"}}
object2 = {"attributes": {}}
answer = {'shape': ('circle', None), 'fill': ('yes', None)}
self.assertEqual(answer,
self.agent.compareAttributes(object1["attributes"],
object2["attributes"]),
msg="null")
def test_performTransform(self):
print("Testing performTransform")
problem = self.problemDict["Basic Problem B-10"]
object1 = problem.figures["A"].objects["a"]
object2 = problem.figures["B"].objects["c"]
transform = self.agent.compareAttributes(object1.attributes,
object2.attributes)
def test_identity_transform(self):
problemB1 = self.problemDict["Basic Problem B-01"]
self.assertEqual(2,
self.agent.Solve(problemB1),
msg="No change to Figure A")
def test_angle_transform(self):
problemB3 = self.problemDict["Basic Problem B-03"]
self.assertEqual(1,
self.agent.Solve(problemB3),
msg="90 degree clockwise rotation of Figure A")
def test_diagonal_relationship(self):
problemB4 = self.problemDict["Basic Problem B-04"]
self.assertEqual(3, self.agent.Solve(problemB4))
def test_one_object_multiple_transform(self):
problemB4 = self.problemDict["Basic Problem B-05"]
self.assertEqual(4, self.agent.Solve(problemB4))
def test_one_object_multiple_transform2(self):
problemB7 = self.problemDict["Basic Problem B-07"]
self.assertEqual(6, self.agent.Solve(problemB7))
def test_one_object_multiple_transform_3(self):
problemB9 = self.problemDict["Basic Problem B-09"]
self.assertEqual(5, self.agent.Solve(problemB9))
def test_two_objects_identity_transform(self):
problemB2 = self.problemDict["Basic Problem B-02"]
self.assertEqual(5, self.agent.Solve(problemB2))
def test_two_objects_interdependent_transform(self):
problemB6 = self.problemDict["Basic Problem B-06"]
self.assertEqual(5, self.agent.Solve(problemB6))
def test_two_objects_interdependent_transform2(self):
problemB11 = self.problemDict["Basic Problem B-11"]
self.assertEqual(1, self.agent.Solve(problemB11))
def test_two_objects_interdependent_transform3(self):
problemB10 = self.problemDict["Basic Problem B-10"]
self.assertEqual(3, self.agent.Solve(problemB10))
def test_two_objects_interdependent_transform4(self):
problemB12 = self.problemDict["Basic Problem B-12"]
self.assertEqual(1, self.agent.Solve(problemB12))
def test_pairObjects(self):
print("test pairObjects")
objects1 = {}
objects1["a"] = RavensObject("a")
objects1["a"].attributes = {"shape": "circle", "fill": "no"}
objects1["b"] = RavensObject("b")
objects1["b"].attributes = {"shape": "square", "fill": "no"}
objects2 = {}
objects2["c"] = RavensObject("c")
objects2["c"].attributes = {"shape": "circle", "fill": "no"}
objects2["d"] = RavensObject("d")
objects2["d"].attributes = {"shape": "square", "fill": "yes"}
pairs = self.agent.pairObjects(objects1, objects2)
result = set()
for pair in pairs:
if pair[0] is not None:
str1 = pair[0].name
else:
str1 = None
if pair[1] is not None:
str2 = pair[1].name
else:
str2 = None
result.add((str1, str2))
answer = set()
answer.add(("a", "c"))
answer.add(("b", "d"))
self.assertEqual(result, answer, msg="Case:same number of objects")
objects1 = {}
objects1["a"] = RavensObject("a")
objects1["a"].attributes = {"shape": "circle", "fill": "no"}
objects1["b"] = RavensObject("b")
objects1["b"].attributes = {"shape": "square", "fill": "no"}
objects2 = {}
objects2["c"] = RavensObject("c")
objects2["c"].attributes = {"shape": "circle", "fill": "no"}
pairs = self.agent.pairObjects(objects1, objects2)
result = set()
for pair in pairs:
if pair[0] is not None:
str1 = pair[0].name
else:
str1 = None
if pair[1] is not None:
str2 = pair[1].name
else:
str2 = None
result.add((str1, str2))
answer = set()
answer.add(("a", "c"))
answer.add(("b", None))
self.assertEqual(result, answer, msg="Case:lost objects")
objects1 = {}
objects1["a"] = RavensObject("a")
objects1["a"].attributes = {"shape": "circle", "fill": "no"}
objects2 = {}
objects2["c"] = RavensObject("c")
objects2["c"].attributes = {"shape": "circle", "fill": "no"}
objects2["d"] = RavensObject("d")
objects2["d"].attributes = {"shape": "square", "fill": "no"}
pairs = self.agent.pairObjects(objects1, objects2)
result = set()
for pair in pairs:
if pair[0] is not None:
str1 = pair[0].name
else:
str1 = None
if pair[1] is not None:
str2 = pair[1].name
else:
str2 = None
result.add((str1, str2))
answer = set()
answer.add(("a", "c"))
answer.add((None, "d"))
self.assertEqual(result, answer, msg="Case:gain objects")
objects1 = {}
objects1["a"] = RavensObject("a")
objects1["a"].attributes = {"shape": "square", "fill": "no"}
objects1["b"] = RavensObject("b")
objects1["b"].attributes = {"shape": "circle", "fill": "no"}
"""
objects2 = {}
objects2["c"] = RavensObject("c")
objects2["c"].attributes = {"shape" : "triangle", "fill" : "no"}
objects2["d"] = RavensObject("d")
objects2["d"].attributes = {"shape" : "circle", "fill" : "yes"}
pairs = self.agent.pairObjects(objects1,objects2)
result = set()
for pair in pairs:
if pair[0] is not None:
str1 = pair[0].name
else:
str1 = None
if pair[1] is not None:
str2 = pair[1].name
else:
str2 = None
result.add((str1,str2))
answer = set()
answer.add(("a","c"))
answer.add(("b","d"))
self.assertEqual(result,answer,msg="Case:local tie")
"""
def test_pairObjectsB10(self):
print("Testing object pairing on Problem B10")
problemB10 = self.problemDict["Basic Problem B-10"]
objectsA = problemB10.figures["A"].objects
objectsB = problemB10.figures["B"].objects
pairs = self.agent.pairObjects(objectsA, objectsB)
result = set()
for pair in pairs:
if pair[0] is not None:
str1 = pair[0].name
else:
str1 = None
if pair[1] is not None:
str2 = pair[1].name
else:
str2 = None
result.add((str1, str2))
answer = set()
answer.add(("a", "c"))
answer.add(("b", "d"))
self.assertEqual(result, answer, msg="Case:horizontal")
objectsC = problemB10.figures["C"].objects
pairs = self.agent.pairObjects(objectsA, objectsC)
result = set()
for pair in pairs:
if pair[0] is not None:
str1 = pair[0].name
else:
str1 = None
if pair[1] is not None:
str2 = pair[1].name
else:
str2 = None
result.add((str1, str2))
answer = set()
answer.add(("a", "e"))
answer.add(("b", "f"))
answer.add((None, "s"))
self.assertEqual(result, answer, msg="Case:vertical")
def test_pairObjectsB11(self):
print("Testing object pairing on Problem B11")
problem = self.problemDict["Basic Problem B-11"]
objectsA = problem.figures["A"].objects
objectsB = problem.figures["B"].objects
pairs = self.agent.pairObjects(objectsA, objectsB)
result = set()
for pair in pairs:
if pair[0] is not None:
str1 = pair[0].name
else:
str1 = None
if pair[1] is not None:
str2 = pair[1].name
else:
str2 = None
result.add((str1, str2))
answer = set()
answer.add(("a", "c"))
answer.add(("b", None))
self.assertEqual(result, answer, msg="Case:horizontal")
objectsC = problem.figures["C"].objects
pairs = self.agent.pairObjects(objectsA, objectsC)
result = set()
for pair in pairs:
if pair[0] is not None:
str1 = pair[0].name
else:
str1 = None
if pair[1] is not None:
str2 = pair[1].name
else:
str2 = None
result.add((str1, str2))
answer = set()
answer.add(("a", "e"))
answer.add(("b", "f"))
self.assertEqual(result, answer, msg="Case:vertical")
def test_pairObjectsB12(self):
print("Testing object pairing on Problem B12")
problem = self.problemDict["Basic Problem B-12"]
objectsA = problem.figures["A"].objects
objectsB = problem.figures["B"].objects
pairs = self.agent.pairObjects(objectsA, objectsB)
result = set()
for pair in pairs:
if pair[0] is not None:
str1 = pair[0].name
else:
str1 = None
if pair[1] is not None:
str2 = pair[1].name
else:
str2 = None
result.add((str1, str2))
answer = set()
answer.add(("a", None))
answer.add(("b", None))
answer.add(("c", "f"))
answer.add(("d", "g"))
answer.add(("e", "h"))
self.assertEqual(result, answer, msg="Case:horizontal")
def testIdentity(self):
print("Testing image identity transform")
problem = self.problemDict["Basic Problem B-01"]
imageFileNameA = problem.figures["A"].visualFilename
imageFileNameB = problem.figures["B"].visualFilename
result = image_processing.checkIdentity(imageFileNameA, imageFileNameB)
self.assertEquals(result, True)
problem = self.problemDict["Basic Problem B-01"]
imageFileNameA = problem.figures["A"].visualFilename
imageFileNameB = problem.figures["1"].visualFilename
result = image_processing.checkIdentity(imageFileNameA, imageFileNameB)
self.assertEquals(result, False)
problem = self.problemDict["Basic Problem B-02"]
imageFileNameA = problem.figures["A"].visualFilename
imageFileNameB = problem.figures["B"].visualFilename
result = image_processing.checkIdentity(imageFileNameA, imageFileNameB)
self.assertEquals(result, True)
problem = self.problemDict["Basic Problem B-02"]
imageFileNameA = problem.figures["A"].visualFilename
imageFileNameB = problem.figures["1"].visualFilename
result = image_processing.checkIdentity(imageFileNameA, imageFileNameB)
self.assertEquals(result, False)
problem = self.problemDict["Basic Problem B-02"]
imageFileNameA = problem.figures["A"].visualFilename
imageFileNameB = problem.figures["2"].visualFilename
result = image_processing.checkIdentity(imageFileNameA, imageFileNameB)
self.assertEquals(result, False)
problem = self.problemDict["Basic Problem B-02"]
imageFileNameA = problem.figures["A"].visualFilename
imageFileNameB = problem.figures["4"].visualFilename
result = image_processing.checkIdentity(imageFileNameA, imageFileNameB)
self.assertEquals(result, False)
def testRotation(self):
print("Testing image rotation transform")
problem = self.problemDict["Basic Problem B-04"]
imageFileNameA = problem.figures["A"].visualFilename
imageFileNameB = problem.figures["B"].visualFilename
result = image_processing.checkRotation(imageFileNameA, imageFileNameB,
270)
self.assertEquals(result, True)
def testReflection(self):
print("Testing image rotation transform")
problem = self.problemDict["Basic Problem B-03"]
imageFileNameA = problem.figures["A"].visualFilename
imageFileNameB = problem.figures["B"].visualFilename
result = image_processing.checkReflection(imageFileNameA,
imageFileNameB, "left_right")
self.assertEquals(result, True)
def tearDown(self):
pass
class TestUM(unittest.TestCase):
def setUp(self):
with warnings.catch_warnings():
warnings.simplefilter("ignore")
#print("=====Setup===== \n")
# taken from RavensProject.py
self.sets = []
r = open(os.path.join("Problems", "ProblemSetList.txt")
) # ProblemSetList.txt lists the sets to solve.
line = getNextLine(
r) # Sets will be solved in the order they appear in the file.
while not line == "": # You may modify ProblemSetList.txt for design and debugging.
self.sets.append(
ProblemSet(line)
) # We will use a fresh copy of all problem sets when grading.
line = getNextLine(r)
r.close()
self.agent = Agent()
self.problemDict = {}
for set in self.sets:
for problem in set.problems:
self.problemDict[problem.name] = problem
#print("=================================")
# Identity
"""
def testD01(self):
print("===================D01")
problem = self.problemDict["Basic Problem D-01"]
self.assertEqual(3, self.agent.Solve(problem))
def testD02(self):
print("===================D02")
problem = self.problemDict["Basic Problem D-02"]
self.assertEqual(1, self.agent.Solve(problem))
def testD03(self):
print("===================D03")
problem = self.problemDict["Basic Problem D-03"]
self.assertEqual(3, self.agent.Solve(problem))
def testD11(self):
print("===================D11")
problem = self.problemDict["Basic Problem D-11"]
self.assertEqual(3, self.agent.Solve(problem))
def testD04(self):
print("===================D04")
problem = self.problemDict["Basic Problem D-04"]
self.assertEqual(1, self.agent.Solve(problem))
def testD05(self):
print("===================D05")
problem = self.problemDict["Basic Problem D-05"]
self.assertEqual(7, self.agent.Solve(problem))
def testD07(self):
print("===================D07")
problem = self.problemDict["Basic Problem D-07"]
self.assertEqual(1, self.agent.Solve(problem))
"""
def testD06(self):
print("===================D06")
problem = self.problemDict["Basic Problem D-06"]
self.assertEqual(1, self.agent.Solve(problem))
def testD09(self):
print("===================D09")
problem = self.problemDict["Basic Problem D-09"]
self.assertEqual(3, self.agent.Solve(problem))
def testD08(self):
print("===================D08")
problem = self.problemDict["Basic Problem D-08"]
self.assertEqual(4, self.agent.Solve(problem))
def testD10(self):
print("===================D10")
problem = self.problemDict["Basic Problem D-10"]
self.assertEqual(1, self.agent.Solve(problem))
def testD12(self):
print("===================D12")
problem = self.problemDict["Basic Problem D-12"]
self.assertEqual(3, self.agent.Solve(problem))
"""
def testD06(self):
print("===================D06")
problem = self.problemDict["Basic Problem D-06"]
self.assertEqual(1, self.agent.Solve(problem))
#########################
"""
"""
def test_seg(self):
print("===================D08")
problem = self.problemDict["Basic Problem D-10"]
question_figures = [problem.figures[key] for key in problem.figures.keys() if key.isalpha() == True]
DPs = {}
for question_figure in question_figures:
DP = image_processing.computeDP(question_figure.visualFilename, "filename")
DPs[question_figure.name] = DP
sorted_DPs = sorted(DPs.items(), key=operator.itemgetter(1))
print(sorted_DPs)
CCs = {}
for question_figure in question_figures:
CC = connectedComponents.computeComponents(question_figure.visualFilename,False)
CCs[question_figure.name] = CC
sorted_CCs = sorted(CCs.items(), key=operator.itemgetter(1))
print(sorted_CCs)
"""
def tearDown(self):
pass
def main():
sets = [] # The variable 'sets' stores multiple problem sets.
# Each problem set comes from a different folder in /Problems/
# Additional sets of problems will be used when grading projects.
# You may also write your own problems.
r = open("Problems" + os.sep + "ProblemSetListTemp.txt"
) # ProblemSetList.txt lists the sets to solve.
line = getNextLine(
r) # Sets will be solved in the order they appear in the file.
while not line == "": # You may modify ProblemSetList.txt for design and debugging.
sets.append(
ProblemSet(line)
) # We will use a fresh copy of all problem sets when grading.
line = getNextLine(
r) # We will also use some problem sets not given in advance.
# Initializing problem-solving agent from Agent.java
agent = Agent(
) # Your agent will be initialized with its default constructor.
# You may modify the default constructor in Agent.java
# Running agent against each problem set
results = open("ProblemResults.csv",
"w") # Results will be written to ProblemResults.csv.
# Note that each run of the program will overwrite the previous results.
# Do not write anything else to ProblemResults.txt during execution of the program.
setResults = open(
"SetResults.csv",
"w") # Set-level summaries will be written to SetResults.csv.
results.write("Problem,Correct Confidence\n")
setResults.write("Set,Sum Correct Confidence\n")
for set in sets:
sum_correct_comfidence = 0
for problem in set.problems: # Your agent will solve one problem at a time.
try:
problem.setAnswerReceived(
agent.Solve(problem)
) # The problem will be passed to your agent as a RavensProblem object as a parameter to the Solve method
# Your agent should return its answer at the conclusion of the execution of Solve.
# Note that if your agent makes use of RavensProblem.check to check its answer, the answer passed to check() will be used.
# Your agent cannot change its answer once it has checked its answer.
correct_comfidence = 0
if type(problem.givenAnswer) is list:
answer = problem.givenAnswer
if len(answer) >= problem.correctAnswer:
if sum(answer) > 1:
sum_answer = float(sum(answer))
answer = [i / sum_answer for i in answer]
correct_comfidence = answer[problem.correctAnswer - 1]
sum_correct_comfidence += correct_comfidence
result = problem.name + "," + str(correct_comfidence)
results.write("%s\n" % result)
except Exception as e:
exceptionType, exceptionValue, exceptionTraceback = sys.exc_info(
)
print("*** print_tb:")
traceback.print_tb(exceptionTraceback,
limit=1,
file=sys.stdout)
print("*** print_exception:")
traceback.print_exception(exceptionType,
exceptionValue,
exceptionTraceback,
limit=2,
file=sys.stdout)
print("*** print_exc:")
traceback.print_exc()
print("*** format_exc, first and last line:")
formatted_lines = traceback.format_exc().splitlines()
print(formatted_lines[0])
print(formatted_lines[-1])
print("*** format_exception:")
print(
repr(
traceback.format_exception(exceptionType,
exceptionValue,
exceptionTraceback)))
print("*** extract_tb:")
print(repr(traceback.extract_tb(exceptionTraceback)))
print("*** format_tb:")
print(repr(traceback.format_tb(exceptionTraceback)))
#print("*** tb_lineno:", traceback.tb_lineno(exceptionTraceback))'''
print("Error encountered in " + problem.name + ":")
print(sys.exc_info()[0])
#result=problem.name + "," + str(problem.givenAnswer) + ",Error,"
#results.write("%s\n" % result)
setResult = set.name + "," + str(sum_correct_comfidence)
setResults.write("%s\n" % setResult)
results.close()
setResults.close()
def main():
sets = [] # The variable 'sets' stores multiple problem sets.
# Each problem set comes from a different folder in /Problems/
# Additional sets of problems will be used when grading projects.
# You may also write your own problems.
for file in os.listdir("Problems (Image Data)"
): # One problem set per folder in /Problems/
if file.startswith('.'):
continue
newSet = VisualProblemSet(
file) # Each problem set is named after the folder in /Problems/
sets.append(newSet)
for problem in os.listdir(
"Problems (Image Data)" + os.sep + file
): # Each file in the problem set folder becomes a problem in that set.
if problem.startswith('.'):
continue
newSet.addProblem(file, problem)
# Initializing problem-solving agent from Agent.java
agent = Agent(
) # Your agent will be initialized with its default constructor.
# You may modify the default constructor in Agent.java
num = 0
# Running agent against each problem set
results = open("Results.txt",
"w") # Results will be written to Results.txt.
# Note that each run of the program will overwrite the previous results.
# Do not write anything else to Results.txt during execution of the program.
h = {}
for set in sets:
results.write(
"%s\n" %
set.getName()) # Your agent will solve one problem set at a time.
results.write(
"%s\n" % "-----------"
) # Problem sets will be individually categorized in the results file.
#if 'Basic' not in set.getName():
# continue
for problem in set.getProblems(
): # Your agent will solve one problem at a time.
#a = problem.checkAnswer("")
#figures = problem.getFigures()
#A = figures["A"].fullpath
#B = figures["B"].fullpath
#C = figures["C"].fullpath
#ans = figures[a].fullpath
#folder = 'templates/template%d' % num
#subprocess.call(['mkdir', folder])
#subprocess.call(['cp', A, '%s/A.png' % folder])
#subprocess.call(['cp', B, '%s/B.png' % folder])
#subprocess.call(['cp', C, '%s/C.png' % folder])
#subprocess.call(['cp', ans, '%s/ans.png' % folder])
#num += 1
problem.setAnswerReceived(
agent.Solve(problem)
) # The problem will be passed to your agent as a RavensProblem object as a parameter to the Solve method
# Your agent should return its answer at the conclusion of the execution of Solve.
# Note that if your agent makes use of RavensProblem.check to check its answer, the answer passed to check() will be used.
# Your agent cannot change its answer once it has checked its answer.
result = problem.getName() + ": " + problem.getGivenAnswer(
) + " " + problem.getCorrect(
) + " (Correct Answer: " + problem.checkAnswer("") + ")"
results.write("%s\n" % result)
results.write("\n")
class TestUM(unittest.TestCase):
def setUp(self):
with warnings.catch_warnings():
warnings.simplefilter("ignore")
#print("=====Setup===== \n")
# taken from RavensProject.py
self.sets=[]
r = open(os.path.join("Problems","ProblemSetList.txt")) # ProblemSetList.txt lists the sets to solve.
line = getNextLine(r) # Sets will be solved in the order they appear in the file.
while not line=="": # You may modify ProblemSetList.txt for design and debugging.
self.sets.append(ProblemSet(line)) # We will use a fresh copy of all problem sets when grading.
line=getNextLine(r)
r.close()
self.agent=Agent()
self.problemDict = {}
for set in self.sets:
for problem in set.problems:
self.problemDict[problem.name] = problem
#print("=================================")
def testC01(self):
print("===================C01")
with warnings.catch_warnings():
warnings.simplefilter("ignore")
problem = self.problemDict["Basic Problem C-01"]
self.assertEqual(3, self.agent.Solve(problem))
print()
def testC07(self):
print("===================C07")
with warnings.catch_warnings():
warnings.simplefilter("ignore")
problem = self.problemDict["Basic Problem C-07"]
self.assertEqual(2, self.agent.Solve(problem))
print()
def testC12(self):
print("===================C12")
with warnings.catch_warnings():
warnings.simplefilter("ignore")
problem = self.problemDict["Basic Problem C-12"]
self.assertEqual(8, self.agent.Solve(problem))
print()
def testC05(self):
print("===================C05")
with warnings.catch_warnings():
warnings.simplefilter("ignore")
problem = self.problemDict["Basic Problem C-05"]
self.assertEqual(3, self.agent.Solve(problem))
print()
def testC04(self):
print("===================C04")
with warnings.catch_warnings():
warnings.simplefilter("ignore")
problem = self.problemDict["Basic Problem C-04"]
self.assertEqual(8, self.agent.Solve(problem))
print()
def testC06(self):
print("===================C06")
with warnings.catch_warnings():
warnings.simplefilter("ignore")
problem = self.problemDict["Basic Problem C-06"]
self.assertEqual(7, self.agent.Solve(problem))
print()
def testC10(self):
print("===================C10")
with warnings.catch_warnings():
warnings.simplefilter("ignore")
problem = self.problemDict["Basic Problem C-10"]
self.assertEqual(7, self.agent.Solve(problem))
print()
def testC11(self):
print("===================C11")
with warnings.catch_warnings():
warnings.simplefilter("ignore")
problem = self.problemDict["Basic Problem C-11"]
self.assertEqual(4, self.agent.Solve(problem))
print()
def testC03(self):
print("===================C03")
with warnings.catch_warnings():
warnings.simplefilter("ignore")
problem = self.problemDict["Basic Problem C-03"]
self.assertEqual(4, self.agent.Solve(problem))
print()
def testC02(self):
print("===================C02")
problem = self.problemDict["Basic Problem C-02"]
self.assertEqual(4, self.agent.Solve(problem))
print("===================C02")
print("Testing object pairing on Problem C02")
problem = self.problemDict["Basic Problem C-02"]
objects1 = problem.figures["E"].objects
objects2 = problem.figures["F"].objects
pairs = self.agent.pairObjects(objects1,objects2)
result = set()
for pair in pairs:
result.add(self.agent.pairToString(pair))
answer = set()
answer.add(("i","k"))
answer.add(("j","l"))
self.assertEqual(result,answer,msg="Case:horizontal")
objects1 = problem.figures["E"].objects
objects2 = problem.figures["H"].objects
pairs = self.agent.pairObjects(objects1,objects2)
result = set()
for pair in pairs:
result.add(self.agent.pairToString(pair))
answer = set()
answer.add(("i","o"))
answer.add(("j","p"))
self.assertEqual(result,answer,msg="Case:vertical")
print("...good")
original = copy.deepcopy(problem.figures["E"].objects)
del_list = []
dummycount = 0
horizontal_pairs = self.agent.pairObjects(problem.figures["E"].objects,problem.figures["F"].objects)
vertical_pairs = self.agent.pairObjects(problem.figures["E"].objects,problem.figures["H"].objects)
for key,value in original.items():
print(key,value.attributes)
self.agent.mutateByTransform(horizontal_pairs,original,del_list,dummycount)
for key,value in original.items():
print(key,value.attributes)
self.agent.mutateByTransform(vertical_pairs,original,del_list,dummycount)
for key,value in original.items():
print(key,value.attributes)
objects3 = problem.figures["4"].objects
for key,value in objects3.items():
print(key,value.attributes)
print()
def testC09(self):
print("===================C09")
problem = self.problemDict["Basic Problem C-09"]
self.assertEqual(2, self.agent.Solve(problem))
print()
def testC08(self):
print("===================C08")
problem = self.problemDict["Basic Problem C-08"]
self.assertEqual(5, self.agent.Solve(problem))
print()
"""
def tearDown(self):
pass
