Generate and test framework
This presentation is the property of its rightful owner.
Sponsored Links
1 / 56

Generate and Test Framework PowerPoint PPT Presentation


  • 59 Views
  • Uploaded on
  • Presentation posted in: General

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

Download Presentation

Generate and Test Framework

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


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

    • 3rd, 4th …

  • Try all of them

    • Remember the best one


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

  • 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


Generating all possible answer


Combination

  • Given N things

  • Generate all possible selections of K things from N things

  • Ex. N = 3, k = 2


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 Padlock


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

  • 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

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


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

  • 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

  • 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

  • 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

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

  • Sols in each step

    • 0

    • 00

    • 000

    • 0000  check

    • 000

    • 0001  check

    • 000

    • 0002  check

    • 000

    • 0003  check

    • 000

    • 00

    • 001

    • 0010  check


Search Tree

0

1

2

3

01

02

03

04

… … … …

… … … …

… … … …


8-queen

  • Given a chess board 8 queens


8-queens problem

  • Try to place the queens so that they don’t get in the others’ ways


Solving the Problem

  • Define the search space

    • What is the search space of this problem?

    • How large it is?

    • Choose an appropriate representation


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!!!


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

  • We go over all position

    • For each position, we either “choose” or “skip” that position for the queen


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 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 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


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?

  • 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

  • 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

  • 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

  • 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

  • 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


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;

}


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

  • 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


Example

  • N = 4

    • 1 + 1 + 1 + 1

    • 1 + 1 + 2

    • 1 + 3

    • 2 + 2

    • 4


Solving with Backtracking

  • Representation

    • Array of ai

  • Step

    • Choosing the next value for ai


Branch & Bound

Technique to reduce enumeration


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


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


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


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

  • 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

  • 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

  • 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

  • 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


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


Keys

  • We must know the so-called “upper bound” of the remaining step

    • It should be compute easily


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 Problem


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

  • 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

  • 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 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


Implement 0-1 Knapsack

Task


  • Login