ce que ce code python essaie de faire

Question

Le code python suivant est de parcourir une grille 2D de (c, g) dans un ordre spécial, qui est stocké dans "jobs" et "job_queue". Mais je ne suis pas sûr de quel ordre il est après avoir essayé de comprendre le code. Est-ce que quelqu'un est capable de parler de l'ordre et de donner des explications sur le but de chaque fonction? Merci et salutations!

import Queue 

c_begin, c_end, c_step = -5, 15, 2 
g_begin, g_end, g_step = 3, -15, -2 

def range_f(begin,end,step): 
    # like range, but works on non-integer too 
    seq = [] 
    while True: 
     if step > 0 and begin > end: break 
     if step < 0 and begin < end: break 
     seq.append(begin) 
     begin = begin + step 
    return seq 

def permute_sequence(seq): 
    n = len(seq) 
    if n <= 1: return seq 

    mid = int(n/2) 
    left = permute_sequence(seq[:mid]) 
    right = permute_sequence(seq[mid+1:]) 

    ret = [seq[mid]] 
    while left or right: 
     if left: ret.append(left.pop(0)) 
     if right: ret.append(right.pop(0)) 

    return ret 

def calculate_jobs(): 
    c_seq = permute_sequence(range_f(c_begin,c_end,c_step)) 
    g_seq = permute_sequence(range_f(g_begin,g_end,g_step)) 
    nr_c = float(len(c_seq)) 
    nr_g = float(len(g_seq)) 
    i = 0 
    j = 0 
    jobs = [] 

    while i < nr_c or j < nr_g: 
     if i/nr_c < j/nr_g: 
      # increase C resolution 
      line = [] 
      for k in range(0,j): 
       line.append((c_seq[i],g_seq[k])) 
      i = i + 1 
      jobs.append(line) 
     else: 
      # increase g resolution 
      line = [] 
      for k in range(0,i): 
       line.append((c_seq[k],g_seq[j])) 
      j = j + 1 
      jobs.append(line) 
    return jobs 

def main(): 

    jobs = calculate_jobs() 
    job_queue = Queue.Queue(0) 

    for line in jobs: 
     for (c,g) in line: 
      job_queue.put((c,g)) 

main() 

---

EDIT:

Il y a une valeur pour chaque (c, g). Le code est en fait de chercher dans la grille 2D de (c, g) pour trouver un point de grille où la valeur est la plus petite. Je suppose que le code utilise une sorte d'algorithme de recherche heuristique? Le code original est ici http://www.csie.ntu.edu.tw/~cjlin/libsvmtools/gridsvr/gridregression.py, qui est un script pour rechercher l'algorithme svm les meilleures valeurs pour deux paramètres c et g avec une erreur de validation minimum.

Answer 1

permute_sequence réorganise une liste de valeurs de sorte que la valeur moyenne soit la première, puis le point milieu de chaque moitié, puis les points milieux des quatre quarts restants, et ainsi de suite. Ainsi permute_sequence(range(1000)) commence comme ceci:

[500, 250, 750, 125, 625, 375, ...] 

calculate_jobs remplit alternativement en rangées et en colonnes à l'aide des séquences de 1D coordonnées fournies par permute_sequence.

Si vous allez chercher l'ensemble de l'espace 2D par la suite, cela ne vous aidera pas à finir plus tôt. Vous pourriez aussi bien balayer tous les points dans l'ordre. Mais je pense que l'idée était de trouver une approximation décent du minimum le plus tôt possible dans la recherche. Je soupçonne que vous pourriez faire à peu près aussi bien en mélangeant la liste au hasard.

lecteurs de xkcd noteront que le urinal protocol donnerait légèrement différents (et probablement mieux) résultats:

[0, 1000, 500, 250, 750, 125, 625, 375, ...] 

Answer 2

Voici un exemple de permute_sequence en action:

print permute_sequence(range(8)) 
# prints [4, 2, 6, 1, 5, 3, 7, 0] 
print permute_sequence(range(12)) 
# prints [6, 3, 9, 1, 8, 5, 11, 0, 7, 4, 10, 2] 

Je ne sais pas pourquoi il utilise cet ordre, parce que dans main, il semble que toutes les paires de candidats de (c, g) sont encore évalué, je pense.