generate and test framework
Download
Skip this Video
Download Presentation
Generate and Test Framework

Loading in 2 Seconds...

play fullscreen
1 / 56

Generate and Test Framework - PowerPoint PPT Presentation


  • 89 Views
  • Uploaded on

Generate and Test Framework. Nattee Niparnan. Optimization Example: Finding Max Value in an Array. There are N possible answers The first element The second element 3 rd , 4 th … Try all of them Remember the best one. Generate and Test Framework. Define the set of admissible solution

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about ' Generate and Test Framework' - jerod


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
optimization example finding max value in an array
Optimization Example: Finding Max Value in an Array
  • There are N possible answers
    • The first element
    • The second element
    • 3rd, 4th …
  • Try all of them
    • Remember the best one
generate and test framework1
Generate and Test Framework
  • Define the set of admissible solution
  • Generate all of them (generating)
  • For each generated solution
    • Test whether it is the one we want
    • By the “evaluation” function (testing)
    • for optimization: remember the best one so far
    • For decision: report when we found the “correct” one
combination and permutation
Combination and Permutation
  • In many case, the set of the admissible solutions is a set of “combination” or “permutation” of something
  • We need to knows how to generate all permutations and combinations
combination
Combination
  • Given N things
  • Generate all possible selections of K things from N things
  • Ex. N = 3, k = 2
combination with replacement
Combination with replacement
  • Given N things
  • Generate all possible selections of K things from N things
    • When something is selected, we are permit to select that things again (we replace the selected thing in the pool)
  • Ex. N = 3, k = 2
breaking the padlock1
Breaking the Padlock
  • Assuming we have four rings
  • Assuming each ring has following mark
    •   
  • We try
    • 
    • 
    • ….
    •  
    • 

Backtracking

Undone the second step, switch to another value

key idea
Key Idea
  • A problem consists of several similar steps
    • Choosing a things from the pool
  • We need to remember the things we done so far
general framework
General Framework

Initial Step

1. Get a step that is not complete

Engine

Storage

Step that have been done

2. Try any possible next step

3. Store each newly generated next step

combination1
Combination
  • Generate all combinations of lock key
  • Represent key by int
    • =0
    • =1
    • =2
    • =3
  • Step = sequence of selected symbols
    • E.g.,
      • ’01’   
      • ‘0003’     
general search
General Search
  • Storage s
  • S  ‘’
  • While s is not empty
    • Curr  Storage.get
    • If Curr is the last step
      • evaluate
    • Else
      • Generate all next step from Curr
      • Push them to S

If length(curr) == 4

For all symbol i

New = curr+I

Storage.push(new)

search space
Search Space
  • Set of all admissible solutions
  • E.g., Combination Padlock
    • Search space = 0000  4444
  • For a task with distinct steps it is easy to enumerate the search space with “backtracking”
  • for most of the case, we can do “backtracking”
backtracking
Backtracking
  • A tool to enumerate the search space
  • Usually using the “stack” to implement the storage
    • Employ the processor stack
    • i.e., using the “recursive” paradigm
combination example by backtracking
Combination Example by Backtracking

void backtracking(intstep,int*sol)

{

if (step < num_step) {

for (inti= 0; i < num_symbol; i++) {

sol[step] = i;

backtracking(step + 1,sol);

}

} else {

check(sol);

}

}

  • The process automatically remember the step
search tree
Search Tree
  • Sols in each step
    • 0
    • 00
    • 000
    • 0000  check
    • 000
    • 0001  check
    • 000
    • 0002  check
    • 000
    • 0003  check
    • 000
    • 00
    • 001
    • 0010  check
search tree1
Search Tree

0

1

2

3

01

02

03

04

… … … …

… … … …

… … … …

8 queen
8-queen
  • Given a chess board 8 queens
8 queens problem
8-queens problem
  • Try to place the queens so that they don’t get in the others’ ways
solving the problem
Solving the Problem
  • Define the search space
    • What is the search space of this problem?
    • How large it is?
    • Choose an appropriate representation
example
Example
  • Every possible placement of queens
    • Size: 648
    • Representation: a set of queens position
      • E.g., (1,1) (1,2) (2,5) (4,1) (1,2) (3,4) (8,8) (7,6)
  • This includes overlapping placement!!!
example1
Example
  • Another representation
    • Try to exclude overlapping
      • Use combination without replacement
    • This is a combination
      • Selecting 8 positions out of 64 positions
      • Size: (64)! / (64 – 8)! * 8!
    • Implementation: in the “generating next step”, check for overlapping
combination without replacement
Combination without replacement
  • We go over all position
    • For each position, we either “choose” or “skip” that position for the queen
combination without replacement1
Combination without replacement

Mark_on_board is a binary string indicate that whether the position is selected

void e_queen(intstep,int *mark_on_board)

{

if (step < 64) {

mark_on_board[step] = 0;

e_queen(step + 1,mark_on_board);

mark_on_board[step] = 1;

e_queen(step + 1,mark_on_board);

} else {

check(mark_on_board);

}

}

Also has to check whether we mark exactly 8 spots

combination without replacement2
Combination without replacement
  • The generated mark_on_board includes
    • 000000000000  select no position (obviously not the answer)
    • 111111000000  select 6 positions (obviously not the answer)
  • We must limit our selection to be exactly 4
combination without replacement3
Combination without replacement

Number of possible 0

void e_queen(intstep,int *mark_on_board,int chosen)

{

if (step < 64) {

if ((64 – 8) – (step – chosen) > 0) {

mark_on_board[step] = 0;

e_queen(step + 1,mark_on_board,chosen);

}

if (8 - chosen > 0) {

mark_on_board[step] = 1;

e_queen(step + 1,mark_on_board,chosen+1);

}

} else {

check(mark_on_board);

}

}

Number of possible 1

example2
Example
  • Any better way?
  • For each row, there should be only one queen
    • Size: 88
    • Representation: sequence of columns
      • E.g., (1,2,3,4,5,6,7,8)
using backtracking
Using Backtracking?
  • The problem consists of 8 step
    • Placing each queen
  • We never sure whether the queen we place would lead to a solution
  • Backtracking is an appropriate way
solving the problem enumerating search space
Solving the Problem: Enumerating Search Space
  • There are eight possible ways in each step
  • There are eight steps
  • Very similar to the combination problem

void e_queen(intstep,int *queen_pos)

{

if (step < 8) {

for (inti = 0; i < 8; i++) {

queen_pos[step] = i;

e_queen(step + 1, queen_pos);

}

} else {

check(queen_pos);

}

}

8 queen by permutation
8-queen by permutation
  • Queen should not be in the same column
    • The solution should never have any column repeated
      • E.g.,
        • (1,2,3,4,5,6,7,1) is bad (column collision
        • (1,1,3,4,5,6,7,5) is bad as well….
        • (1,2,3,4,5,6,7,8) is good
          • There should be no duplicate column index!!!
permutation
Permutation
  • Given N symbols
  • A permutation is the element arrange in any order
    • E.g., 1 2 3 4
    • Shows
      • 1 2 3 4
      • 1 2 4 3
      • 1 3 2 4
      • 1 3 4 2
      • 4 3 2 1
  • For each step, we have to known which one is used
permutation by backtracking
Permutation by Backtracking
  • The problem consists of several similar steps
  • Special condition
    • Symbols never repeat
  • How to do?
    • Easy way:
      • Generate all combination (as done before)
        • Check for ones that symbols do not repeat
    • Better way:
      • Remember what symbols are used
permutation1
Permutation

void backtracking(intstep,int *sol)

{

if (step < num_step) {

for (inti = 0; i < num_symbol; i++) {

if not_used(sol,i,step) {

sol[step] = i;

backtracking(step,sol);

}

}

} else {

check(sol);

}

}

Boolnot_used(int *sol,intvalue,int step)

{

for (inti = 0;i < step; i++) {

if (sol[i] == value) return false;

}

return true;

}

permutation2
Permutation
  • More proper ways
  • void backtracking(intstep,int*sol,bool *used)
  • {
  • if (step < num_step) {
  • for (inti= 0; i < num_symbol; i++) {
  • if (!used[i]) {
  • used[i] = true;
  • sol[step]= i;
    • backtracking(step,sol,used);
    • used[i] = false;
    • }
  • }
  • } else {
  • check(sol);
  • }
  • }
backtracking problems
Backtracking Problems
  • Given N
    • Find any sequence of (a1,a2,a3,…) such that
      • a1 +a2 + a3 +… + ak = N
      • ai > 0
      • ai<= aj for all i < j
      • aiis an integer
example3
Example
  • N = 4
    • 1 + 1 + 1 + 1
    • 1 + 1 + 2
    • 1 + 3
    • 2 + 2
    • 4
solving with backtracking
Solving with Backtracking
  • Representation
    • Array of ai
  • Step
    • Choosing the next value for ai
branch bound
Branch & Bound

Technique to reduce enumeration

main idea
Main Idea
  • We should not enumerate solution that will never produce a solution
  • We have done that!!!
    • 8-queens
    • By naïve combination, we will have to do all 648
      • But, by each improvement, we further reduce what we have to do
permutation3
Permutation

0

1

2

00

01

02

10

11

12

20

21

22

000

001

002

010

011

012

020

021

022

100

101

102

110

111

112

120

121

122

200

201

202

210

211

212

220

221

222

permutation4
Permutation

0

1

2

00

01

02

10

11

12

20

21

22

000

001

002

010

011

012

020

021

022

100

101

102

110

111

112

120

121

122

200

201

202

210

211

212

220

221

222

slide43
Key
  • If we know, at any step, that the solution is not feasible
    • Then, it is futile to further search along that path
optimization problem
Optimization Problem
  • All previous examples are decision problems
    • Asking whether the solution satisfy the criteria
  • Now, we consider broader set of problem, the optimization problem
  • Example
    • For all students, find one with maximum height
evaluation
Evaluation
  • Representation: x = id of student
  • “goodness evaluation” evaluate(x)
  • For all x in the search space, we have to find one with maximum evaluate(x)
solving optimization problem
Solving Optimization Problem
  • Enumerate all possible solution
  • Calculate its value
    • Remember the max

void backtracking(int step,int *sol)

{

if (step < num_step) {

for (int i = 0; i < num_symbol; i++) {

sol[step] = i;

backtracking(step,sol);

}

} else {

value = evaluate(sol);

if (value > max) remember(value,sol);

}

}

branch bound in optimization problem
Branch & Bound in Optimization Problem
  • For many problems, it is possible to assert its goodness even the solution is not complete
  • If we can predict the best value for the remaining step, then we can use that value to “bound” our search
example4
Example
  • Assuming that we have 10 steps
  • At step 7, the goodness of the partial solution is X
  • Assuming that we know that the remaining step could not produce a solution better than Y
    • If we have found a solution better than X+Y
      • We can simply “bound” the search
slide49
Keys
  • We must know the so-called “upper bound” of the remaining step
    • It should be compute easily
example5
Example

Let value at this point be 10

If we know that this path never bet higher than 13 (which make 10 + 13 < 35)

We can neglect it

23

35

2

knapsack problem1
Knapsack Problem
  • Given a sack, able to hold K kg
  • Given a list of objects
    • Each has a weight and a value
  • Try to pack the object in the sack so that the total value is maximized
variation
Variation
  • Rational Knapsack
    • Object is like a gold bar, we can cut it in to piece with the same value/weight
  • 0-1 Knapsack
    • Object cannot be broken, we have to choose to take (1) or leave (0) the object
    • E.g.
      • K = 50
      • Objects = (60,10) (100,20) (120,30)
      • Best solution = choose second and third
rational knapsack
Rational Knapsack
  • Can be solved by greedy
  • Sort object according to value/weight ratio
  • Pick objects by that ratio
    • If object is larger than the remaining capacity, just divide it
0 1 knapsack with b b
0-1 Knapsack with B&B
  • 0-1 knapsack is very suitable for B&B
    • We can calculate the goodness of the partial solution
      • Just sum the value of the selected objects
    • We have fast, good upper bounds (several one)
      • The sum of remaining unselected objects
        • The sum of remaining unselected object that don’t exceed the capacity
      • The solution of the “rational knapsack” of the remaining objects with the remaining capacity
ad