{"id":349,"date":"2022-06-06T19:17:13","date_gmt":"2022-06-06T18:17:13","guid":{"rendered":"https:\/\/www.maidaccordo.net\/blog\/?p=349"},"modified":"2023-04-11T19:36:50","modified_gmt":"2023-04-11T18:36:50","slug":"pregiudizi-su-python-e-numpy","status":"publish","type":"post","link":"https:\/\/www.maidaccordo.net\/blog\/2022\/06\/pregiudizi-su-python-e-numpy\/","title":{"rendered":"Pregiudizi su python e numpy"},"content":{"rendered":"\n

A volte le nostre convinzioni sono basate sul nulla e alla prova dei fatti sono sbagliate.<\/p>\n\n\n\n

Il python \u00e8 un linguaggio interpretato e come tale \u00e8 lento: \u00e8 vero ma a volte a complicare
le cose ci si mettono anche i nostri <\/strong>pregiudizi.<\/strong><\/p>\n\n\n\n\n\n\n\n

Dovevo produrre un vettore e per farlo, nella notte dei tempi, avevo scritto una funzioncina stupida:<\/p>\n\n\n

def<\/span> old_grid_generator<\/span>()<\/span>:<\/span>\n<\/span><\/mark>      Psealevel    = 1000.0<\/span>\n<\/span><\/mark>      scale_height = 6.0<\/span>\n<\/span><\/mark>      Zdummy       = np.concatenate((np.arange(80<\/span>,55<\/span>,-2<\/span>),np.arange(54<\/span>,4<\/span>,-1<\/span>)))\n<\/span><\/mark>      return<\/span> Psealevel * np.exp(-Zdummy \/ scale_height)\n<\/span><\/mark><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Come si intuisce ho usato la libreria numpy nella convinzione che la libreria, compilata dal C, facesse un buon lavoro. Ma siccome il mio cervello funziona male, qualche tempo fa, riguardandola, mi sono chiesto se questa cosa fosse vera. Allora mi sono messo a pensare 5 minuti a come avrei potuto scrivere del codice “pure python” ragionevolmente veloce, il primo risultato \u00e8 stato questo:<\/p>\n\n\n
def<\/span> old_grid_generator_2<\/span>()<\/span>:<\/span>\n<\/span><\/mark>      Psealevel    = 1000.0<\/span>\n<\/span><\/mark>      scale_height = 6.0<\/span>\n<\/span><\/mark>      from<\/span> math import<\/span> exp\n<\/span><\/mark>      return<\/span> ( Psealevel * exp(-zz \/ scale_height) for<\/span> zz in<\/span> (*range(80<\/span>,55<\/span>,-2<\/span>),*range(54<\/span>,4<\/span>,-1<\/span>)) )\n<\/span><\/mark><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
confrontando i tempi che impiegano a girare:<\/p>\n\n\n
In<\/span> [302]<\/span>: %timeit<\/span> old_grid_generator<\/span>()\n5.38<\/span> \u00b5s<\/span> \u00b1 40 ns<\/span> per<\/span> loop<\/span> (mean<\/span> \u00b1 std<\/span>. dev<\/span>. of<\/span> 7 runs<\/span>, 100000 loops<\/span> each<\/span>)\n\nIn<\/span> [333]<\/span>: %timeit<\/span> old_grid_generator_2<\/span>()\n1.39<\/span> \u00b5s<\/span> \u00b1 28 ns<\/span> per<\/span> loop<\/span> (mean<\/span> \u00b1 std<\/span>. dev<\/span>. of<\/span> 7 runs<\/span>, 1000000 loops<\/span> each<\/span>)<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
Meglio se  importo exp fuori dalla funzione<\/p>\n\n\n
In<\/span> [32]<\/span>: %timeit<\/span> old_grid_generator_2<\/span>()\n925 ns<\/span> \u00b1 9.11<\/span> ns<\/span> per<\/span> loop<\/span> (mean<\/span> \u00b1 std<\/span>. dev<\/span>. of<\/span> 7 runs<\/span>, 1000000 loops<\/span> each<\/span>)<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
Ancora meglio se uso la funzione itertools.chain per concatenare 2 generatori senza passare per la tupla, per convenienza ne ho fatto una terza versione.<\/p>\n\n\n
from<\/span> itertools import<\/span> chain\ndef old_grid_generator_3():\n    Psealevel    = 1000.0<\/span>\n    scale_height = 6.0<\/span>\n    return<\/span> ( Psealevel * exp(-zz \/ scale_height) for<\/span> zz in<\/span> chain(range(80<\/span>,55<\/span>,-2<\/span>),range(54<\/span>,4<\/span>,-1<\/span>)))\n\nIn [114<\/span>]: %timeit old_grid_generator_3()\n516<\/span> ns \u00b1 2<\/span> ns per loop (mean \u00b1 std. dev. of 7<\/span> runs, 1000000<\/span> loops each)<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
Ah, quindi in questo caso particolare il python da solo fa 10 volte meglio di numpy.
Vabb\u00e8, mi sono detto, sto barando: la prima versione tira fuori un utilissimo
numpy.array mentre la seconda un banalissimo generatore. Allora:<\/p>\n\n\n
In<\/span> [116]<\/span>: %timeit<\/span> np<\/span>.fromiter<\/span>(old_grid_generator_3<\/span>(),float<\/span>)\n9.47<\/span> \u00b5s<\/span> \u00b1 152 ns<\/span> per<\/span> loop<\/span> (mean<\/span> \u00b1 std<\/span>. dev<\/span>. of<\/span> 7 runs<\/span>, 100000 loops<\/span> each<\/span>)<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
Viene fuori che se gli faccio costruire il vettore numpy il tempo \u00e8 2 volte quello che ci mette la versione nativa numpy: se lo riprende con gli interessi. Quindi scrivere codice che usa le numpy nativamente \u00e8 pi\u00f9 efficiente che scrivere codice veloce in puro python e poi convertire i risultati in numpy.<\/p>\n\n\n\n
Allora mi chiedo se a richiedere tempo \u00e8 il vettore numpy o il fatto di voler “mettere a terra” il risultato immagazzinandolo in memoria.<\/p>\n\n\n\n
Per testare questa ipotesi genero una tupla, oggetto decisamente pi\u00f9 snello di un array numpy:<\/p>\n\n\n
In<\/span> [138]<\/span>: %timeit<\/span> tuple<\/span>(old_grid_generator_3<\/span>())\n7.49<\/span> \u00b5s<\/span> \u00b1 29.1<\/span> ns<\/span> per<\/span> loop<\/span> (mean<\/span> \u00b1 std<\/span>. dev<\/span>. of<\/span> 7 runs<\/span>, 100000 loops<\/span> each<\/span>)<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
Ottengo risultati simili se la tupla la genero all’interno della funzione.<\/p>\n\n\n\n
Evidentemente l’operazione che prende tempo \u00e8 chiedere che i valori vengano immagazzinati in un oggetto in memoria. <\/p>\n\n\n\n
Ne deduco che se riuscissimo a ottenere tutti i nostri risultati usando soltanto generatori, senza mai appoggiarli in memoria, se non in ultima istanza, probabilmente otterremmo del codice rapido (confrontabile o quasi coi risultati delle numpy) e molto meno pesante in memoria. Per dirla in modo pi\u00f9 sintetico, se scrivessimo il codice in modo un po’ pi\u00f9 “funzionale”. <\/p>\n\n\n\n
Non sono sicuro che sia sempre fattibile…<\/p>\n\n\n\n
Quel che resterebbe da capire \u00e8 come questo comportamento scali all’aumentare del numero di elementi del vettore.<\/p>\n\n\n\n
Questo semplice esempio fa vedere \u00e8 come in alcuni casi (attenzione a generalizzare) il design progettuale del “nuovo” python3 e quello delle numpy sono in aperto disaccordo.<\/p>\n\n\n\n
Ma l’insegnamento pi\u00f9 importante \u00e8 quello di fermarsi un attimo a pensare prima di scrivere del codice, anche quello che svolge lavori banali.<\/p>\n","protected":false},"excerpt":{"rendered":"
A volte le nostre convinzioni sono basate sul nulla e alla prova dei fatti sono sbagliate. Il python \u00e8 un linguaggio interpretato e come tale \u00e8 lento: \u00e8 vero ma a volte a complicarele cose ci si mettono anche i … Continue reading →<\/span><\/a><\/p>\n","protected":false},"author":4,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[4],"tags":[],"class_list":["post-349","post","type-post","status-publish","format-standard","hentry","category-hardsoft"],"_links":{"self":[{"href":"https:\/\/www.maidaccordo.net\/blog\/wp-json\/wp\/v2\/posts\/349","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.maidaccordo.net\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.maidaccordo.net\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.maidaccordo.net\/blog\/wp-json\/wp\/v2\/users\/4"}],"replies":[{"embeddable":true,"href":"https:\/\/www.maidaccordo.net\/blog\/wp-json\/wp\/v2\/comments?post=349"}],"version-history":[{"count":22,"href":"https:\/\/www.maidaccordo.net\/blog\/wp-json\/wp\/v2\/posts\/349\/revisions"}],"predecessor-version":[{"id":400,"href":"https:\/\/www.maidaccordo.net\/blog\/wp-json\/wp\/v2\/posts\/349\/revisions\/400"}],"wp:attachment":[{"href":"https:\/\/www.maidaccordo.net\/blog\/wp-json\/wp\/v2\/media?parent=349"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.maidaccordo.net\/blog\/wp-json\/wp\/v2\/categories?post=349"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.maidaccordo.net\/blog\/wp-json\/wp\/v2\/tags?post=349"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}