Re: [Python] Utilizzo completo della cpu
[..skip... ] Ho la funzione fp del tipo numeratore/denominatore dove numeratore e denominatore sono dei polinomi di secondo grado. Proverò con il suggerimento di usare la def al posto di lambda (può aiutare per le prestazioni?) Credo che potrebbe farti guadagnare un massimo del 10%. Se il tempo impiegato è ancora troppo lungo, l'unico consiglio che posso darti è di riscrivere il tutto in C. Per il tuo problema si trovano diverse implementazioni in C, vedi ad esempio: http://en.wikipedia.org/wiki/Levenberg–Marquardt_algorithm Purtroppo il tuo è un caso abbastanza sfortunato. L'implementazione dell'algoritmo in SciPy è un semplice wrapper di una funzione scritta in Fortran (minpack), e che quindi dovrebbe essere abbastanza efficiente. Il problema è che viene chiamata la tua funzione, scritta in Python, moltissime volte all'interno di un ciclo. Le chiamate a funzione in Python sono abbastanza onerose; di solito non è un problema ma nel tuo caso lo è. Non solo la chiamata alla funzione e' un po' onerosa ma soprattutto direi e' oneroso il calcolo della jacobiano fatto per via numerica. Per questo suggerisco l'uso di numexpr (http://code.google.com/p/numexpr/) che offre la possibilita' di precompilare la funzione (e le sue derivate, se analitiche) per velocizzare il calcolo. Questo nel mio codice che suggerito precedentemente e' gia' implementato. Mi accorgo ora che proprio numexpr ha la possibilità di usare piu' core: i dettagli qui http://code.google.com/p/numexpr/wiki/MultiThreadVM ciao gianfranco ___ Python mailing list Python@lists.python.it http://lists.python.it/mailman/listinfo/python
Re: [Python] Utilizzo completo della cpu
Non credo nel tuo caso. Il codice python in linea di massima non può essere eseguito in multithread, nel senso che l'interprete può esegure un solo opcode alla volta. Ma se questo opcode è lungo di suo, per esempio legge da un file, o dalla rete, o fa qualcosa di complesso ma restando in C, senza toccare pezzi di python, allora può rilasciare il GIL e permettere ad altri thread di correre in parallelo. Di conseguenza, un programma python può beneficiare di multithread solo quando è IO-bound, non quando è CPU-bound, e il tempo di CPU è speso in codice Python. Nota che - se ricordo bene - numpy rilascia il GIL per le operazioni implementate in C, ovvero, se fai A + B dove A e B sono matrici 1 x 1, mentre le somma può permettere ad altro codice (python o meno) di correre. Ma la funzione leastsq, anche se è scritta in C, valuta continuamente la fp che, essendo scritta in Python, ha bisogno di aspettare il GIL per essere eseguita. Le cose si complicano Ho capito (forse) il 50% di quello che hai scritto (per colpa mia naturalmente). Quando mi rapporto con questa lista mi rendo conto di saperne veramente poco... ;) Al di là della prestazione di Python coi thread, non credo che la leastsq sia parallelizzabile: se non dico cappellate, l'algoritmo consiste in valutare continuamente la funzione in un numero di punti e ogni valutazione ha bisogno dei risultati precedenti, quindi non mi sembra un problema adatto ad essere parallelizzato. Penso invece che dopo una prima inizializzazione del calcolo il tutto si riconduca a dei calcoli matriciali ma è passato un po' di tempo dagli esami di calcolo numerico. Grazie MAtteo ___ Python mailing list Python@lists.python.it http://lists.python.it/mailman/listinfo/python
Re: [Python] Utilizzo completo della cpu
ho una funzione fp non lineare che deve essere ottimizzata... fp = lambda v, x,y, phi:(1+v[0]*phi+v[1]*x+v[2]*x*phi+v[3]*y+v[4]*y*phi+v[5]*x**2... +v[6]*phi*x**2+v[7]*y**2+v[8]*phi*y**2+v[9]*x*y+v[10]*phi*x*y)/(v[11]+v[12]*phi... +v[13]*x+v[14]*x*phi+v[15]*y+v[16]*y*phi+v[17]*x**2+v[18]*phi*x**2+v[19]*y**2... +v[20]*phi*y**2+v[21]*x*y+v[22]*phi*x*y) Prima che ti complichi la vita con una implementazione parallela, ti consiglio di ottimizzare l'implementazione attuale. In particolare, nella definizione di fp vedo *molti* termini che sono calcolati ripetutamente, mentre possono essere pre-calcolati una sola volta. Questo punto mi interessa molto e ci avevo già pensato ma non avevo trovato il modo di semplificare. Ho la funzione fp del tipo numeratore/denominatore dove numeratore e denominatore sono dei polinomi di secondo grado. Proverò con il suggerimento di usare la def al posto di lambda (può aiutare per le prestazioni?) Non mi viene in mente altro Ciao Matteo ___ Python mailing list Python@lists.python.it http://lists.python.it/mailman/listinfo/python
Re: [Python] Utilizzo completo della cpu
-BEGIN PGP SIGNED MESSAGE- Hash: SHA1 Il 18/11/2011 08:54, Matteo Perini ha scritto: [...] Però non riesco a capire se è possibile applicarlo anche ad un unico comando. Che intendi come comando? Scusami ma non conosco la terminologia corretta Io per comando intendevo leastsq(e, v0, args=(x,y,phi,z), maxfev=1) Ok. Allora la risposta completa è: No, non è assolutamente possibile parallelizzare. [...] Se ho capito bene potrei usare: def fp(v, x, y, phi): return (1+v[0]*phi+v[1]*x+v[2]*x*phi+v[3]*y+v[4]*y*phi+v[5]*x**2... +v[6]*phi*x**2+v[7]*y**2+v[8]*phi*y**2+v[9]*x*y+v[10]*phi*x*y)/(v[11]+v[12]*phi... +v[13]*x+v[14]*x*phi+v[15]*y+v[16]*y*phi+v[17]*x**2+v[18]*phi*x**2+v[19]*y**2... +v[20]*phi*y**2+v[21]*x*y+v[22]*phi*x*y) Giusto? Esatto. Devi parallelizzare l'algoritmo, e di solito non è banale. In letteratura dovresti trovare algoritmi per l'ottimizzazione ai minimi quadrati paralleli, magari trovi anche implementazioni già pronte. Una volta che hai l'algoritmo, l'altro problema è l'implementazione (anche questo non banalissimo). Mmmm la vedo mooolto dura per le mie conoscenze. Per il tuo problema è dura anche per esperti! [...] Ciao Manlio -BEGIN PGP SIGNATURE- Version: GnuPG v1.4.10 (GNU/Linux) Comment: Using GnuPG with Mozilla - http://enigmail.mozdev.org/ iEYEARECAAYFAk7GvMoACgkQscQJ24LbaURCnwCfVTp+LNDLFSc6oj2Qtoe6OyWu RAsAniV0y/M/Q5votRQRIzbLdWTqtJeU =z58I -END PGP SIGNATURE- ___ Python mailing list Python@lists.python.it http://lists.python.it/mailman/listinfo/python
Re: [Python] Utilizzo completo della cpu
-BEGIN PGP SIGNED MESSAGE- Hash: SHA1 Il 18/11/2011 09:06, Matteo Perini ha scritto: ho una funzione fp non lineare che deve essere ottimizzata... fp = lambda v, x,y, phi:(1+v[0]*phi+v[1]*x+v[2]*x*phi+v[3]*y+v[4]*y*phi+v[5]*x**2... +v[6]*phi*x**2+v[7]*y**2+v[8]*phi*y**2+v[9]*x*y+v[10]*phi*x*y)/(v[11]+v[12]*phi... +v[13]*x+v[14]*x*phi+v[15]*y+v[16]*y*phi+v[17]*x**2+v[18]*phi*x**2+v[19]*y**2... +v[20]*phi*y**2+v[21]*x*y+v[22]*phi*x*y) [...] Questo punto mi interessa molto e ci avevo già pensato ma non avevo trovato il modo di semplificare. http://paste.pocoo.org/show/509927/ Ma attenzione che potrebbe contenere degli errori. Ho la funzione fp del tipo numeratore/denominatore dove numeratore e denominatore sono dei polinomi di secondo grado. Proverò con il suggerimento di usare la def al posto di lambda (può aiutare per le prestazioni?) Credo che potrebbe farti guadagnare un massimo del 10%. Se il tempo impiegato è ancora troppo lungo, l'unico consiglio che posso darti è di riscrivere il tutto in C. Per il tuo problema si trovano diverse implementazioni in C, vedi ad esempio: http://en.wikipedia.org/wiki/Levenberg–Marquardt_algorithm Purtroppo il tuo è un caso abbastanza sfortunato. L'implementazione dell'algoritmo in SciPy è un semplice wrapper di una funzione scritta in Fortran (minpack), e che quindi dovrebbe essere abbastanza efficiente. Il problema è che viene chiamata la tua funzione, scritta in Python, moltissime volte all'interno di un ciclo. Le chiamate a funzione in Python sono abbastanza onerose; di solito non è un problema ma nel tuo caso lo è. Non dovrebbe essere un problema riscrivere parte del codice in C e misurare di quanto migliorano le prestazioni. Magari mi sbaglio ed il collo di bottiglia non è dove io penso che sia. [...] Ciao Manlio -BEGIN PGP SIGNATURE- Version: GnuPG v1.4.10 (GNU/Linux) Comment: Using GnuPG with Mozilla - http://enigmail.mozdev.org/ iEYEARECAAYFAk7Gvr4ACgkQscQJ24LbaUQgywCeKp/VGVX72waz3LZQMqympFws RT0AnAkNxxhYuVXY7j3fYK/ICdqz3EsN =TLaS -END PGP SIGNATURE- ___ Python mailing list Python@lists.python.it http://lists.python.it/mailman/listinfo/python
Re: [Python] Utilizzo completo della cpu
usa + processi. Il 17 novembre 2011 17:19, Matteo Perini perini.mat...@gmail.com ha scritto: Ciao lista, Vorrei sapere se è possibile utilizzare tutti i core della cpu per eseguire calcoli gravosi. Ho guardato un po' in internet e come risposta ho trovato il multithreading che ho già utilizzato un paio di volte. Però non riesco a capire se è possibile applicarlo anche ad un unico comando. Mi spiego meglio. ho una funzione fp non lineare che deve essere ottimizzata... fp = lambda v, x,y, phi:(1+v[0]*phi+v[1]*x+v[2]*x*phi+v[3]*y+v[4]*y*phi+v[5]*x**2... +v[6]*phi*x**2+v[7]*y**2+v[8]*phi*y**2+v[9]*x*y+v[10]*phi*x*y)/(v[11]+v[12]*phi... +v[13]*x+v[14]*x*phi+v[15]*y+v[16]*y*phi+v[17]*x**2+v[18]*phi*x**2+v[19]*y**2... +v[20]*phi*y**2+v[21]*x*y+v[22]*phi*x*y) imposto la funzione obiettivo e = lambda v, x,y, phi, z: (fp(v,x,y,phi)-z) e infine avvio il processo di ottimizzazzione ai minimi quadrati v, success = leastsq(e, v0, args=(x,y,phi,z), maxfev=1) Questo va avanti per minuti e usa un solo core. C'è un modo per suddividere i calcoli di leastsq tra più core? (spero di si) Grazie a tutti dell'aiuto sempre pronto Ciao Matteo ___ Python mailing list Python@lists.python.it http://lists.python.it/mailman/listinfo/python -- Quiero ser el rayo de sol que cada día te despierta para hacerte respirar y vivir en me. Favola -Moda. ___ Python mailing list Python@lists.python.it http://lists.python.it/mailman/listinfo/python
Re: [Python] Utilizzo completo della cpu
On Fri, 18 Nov 2011 23:18:06 +0100, Giorgio Zoppi giorgio.zo...@gmail.com wrote: usa + processi. clap clap... -- Daniele Varrazzo - Develer S.r.l. http://www.develer.com ___ Python mailing list Python@lists.python.it http://lists.python.it/mailman/listinfo/python
[Python] Utilizzo completo della cpu
Ciao lista, Vorrei sapere se è possibile utilizzare tutti i core della cpu per eseguire calcoli gravosi. Ho guardato un po' in internet e come risposta ho trovato il multithreading che ho già utilizzato un paio di volte. Però non riesco a capire se è possibile applicarlo anche ad un unico comando. Mi spiego meglio. ho una funzione fp non lineare che deve essere ottimizzata... fp = lambda v, x,y, phi:(1+v[0]*phi+v[1]*x+v[2]*x*phi+v[3]*y+v[4]*y*phi+v[5]*x**2... +v[6]*phi*x**2+v[7]*y**2+v[8]*phi*y**2+v[9]*x*y+v[10]*phi*x*y)/(v[11]+v[12]*phi... +v[13]*x+v[14]*x*phi+v[15]*y+v[16]*y*phi+v[17]*x**2+v[18]*phi*x**2+v[19]*y**2... +v[20]*phi*y**2+v[21]*x*y+v[22]*phi*x*y) imposto la funzione obiettivo e = lambda v, x,y, phi, z: (fp(v,x,y,phi)-z) e infine avvio il processo di ottimizzazzione ai minimi quadrati v, success = leastsq(e, v0, args=(x,y,phi,z), maxfev=1) Questo va avanti per minuti e usa un solo core. C'è un modo per suddividere i calcoli di leastsq tra più core? (spero di si) Grazie a tutti dell'aiuto sempre pronto Ciao Matteo ___ Python mailing list Python@lists.python.it http://lists.python.it/mailman/listinfo/python
Re: [Python] Utilizzo completo della cpu
- Original Message - Ciao lista, Vorrei sapere se è possibile utilizzare tutti i core della cpu per eseguire calcoli gravosi. Ho guardato un po' in internet e come risposta ho trovato il multithreading che ho già utilizzato un paio di volte. Però non riesco a capire se è possibile applicarlo anche ad un unico comando. Mi spiego meglio. ho una funzione fp non lineare che deve essere ottimizzata... fp = lambda v, x,y, phi:(1+v[0]*phi+v[1]*x+v[2]*x*phi+v[3]*y+v[4]*y*phi+v[5]*x**2... +v[6]*phi*x**2+v[7]*y**2+v[8]*phi*y**2+v[9]*x*y+v[10]*phi*x*y)/(v[11]+v[12]*phi... +v[13]*x+v[14]*x*phi+v[15]*y+v[16]*y*phi+v[17]*x**2+v[18]*phi*x**2+v[19]*y**2... +v[20]*phi*y**2+v[21]*x*y+v[22]*phi*x*y) imposto la funzione obiettivo e = lambda v, x,y, phi, z: (fp(v,x,y,phi)-z) e infine avvio il processo di ottimizzazzione ai minimi quadrati v, success = leastsq(e, v0, args=(x,y,phi,z), maxfev=1) Questo va avanti per minuti e usa un solo core. C'è un modo per suddividere i calcoli di leastsq tra più core? (spero di si) Grazie a tutti dell'aiuto sempre pronto Ciao Matteo Matteo, oggi ti tempesto... Io non so nulla di calcolo su più core, ma faccio molto i minimi quadrati. Se ti interessa sto sviluppando un sistema semplice per fare tutto da riga di comando, lo trovi qui: https://github.com/gdurin/pyFitting la cosa che ti potrebbe aiutare potrebbe essere utilizzare le derivate analitiche (il mio parametro -d), che diminuiscono sensibilmente il numero di passi da far fare alla routine. Oppure prendi spunto per farlo tu (ho usato sympy e numexpr per compilare e ottimizzare il calcolo) Per ogni dettaglio puoi vedere qui in un talk che ho fatto di recente: http://emma.inrim.it:8080/gdurin/talks/fit-the-elefant-on-the-use-of-least-square-methods-from-simple-cases-to-multiparameter-scaling-functions/ Certo, fittare con 22 parametri è un bel problema, ed è proprio fittare un elefante (che pare abbia bisogno di 'soli' 13 parametri). Un problema noto è che spesso molti sistemi (le funzioni teoriche) sono 'sloppy', cioé poco sensibili alle variazioni anche ampie dei parametri. Quindi il fit non si muove mai, soprattutto se hai le derivate (per il calcolo dello jacobiano) numeriche. Inoltre di solito è un casino decidere i valori iniziali, soprattutto nel tuo caso (so che qualcuno usa degli algoritmi genetici per la stima dei valori iniziali, ma non ne so molto). Cose biologiche? ciao Gianfranco ___ Python mailing list Python@lists.python.it http://lists.python.it/mailman/listinfo/python ___ Python mailing list Python@lists.python.it http://lists.python.it/mailman/listinfo/python
Re: [Python] Utilizzo completo della cpu
-BEGIN PGP SIGNED MESSAGE- Hash: SHA1 Il 17/11/2011 17:19, Matteo Perini ha scritto: Ciao lista, Vorrei sapere se è possibile utilizzare tutti i core della cpu per eseguire calcoli gravosi. Si. Come è possibile usare anche tutte le cpu dei computer in una rete. Il come è un altro discorso... Ho guardato un po' in internet e come risposta ho trovato il multithreading che ho già utilizzato un paio di volte. Il multithreading in Python non va bene, a meno di condizioni particolari (cerca su Internet Python GIL). Però non riesco a capire se è possibile applicarlo anche ad un unico comando. Che intendi come comando? Mi spiego meglio. ho una funzione fp non lineare che deve essere ottimizzata... fp = lambda v, x,y, phi:(1+v[0]*phi+v[1]*x+v[2]*x*phi+v[3]*y+v[4]*y*phi+v[5]*x**2... +v[6]*phi*x**2+v[7]*y**2+v[8]*phi*y**2+v[9]*x*y+v[10]*phi*x*y)/(v[11]+v[12]*phi... +v[13]*x+v[14]*x*phi+v[15]*y+v[16]*y*phi+v[17]*x**2+v[18]*phi*x**2+v[19]*y**2... +v[20]*phi*y**2+v[21]*x*y+v[22]*phi*x*y) Scusa, ma perchè usi lambda? Nel tuo caso rende il codice meno leggibile. Fai un più semplice: def fp(v, x, y, phi): ... Le lambda dovrebbero essere usate *solo* se ti serve una funzione anonima (ad esempio per passarla come argomento ad un altra funzione). imposto la funzione obiettivo e = lambda v, x,y, phi, z: (fp(v,x,y,phi)-z) e infine avvio il processo di ottimizzazzione ai minimi quadrati v, success = leastsq(e, v0, args=(x,y,phi,z), maxfev=1) Questo va avanti per minuti e usa un solo core. C'è un modo per suddividere i calcoli di leastsq tra più core? (spero di si) Devi parallelizzare l'algoritmo, e di solito non è banale. In letteratura dovresti trovare algoritmi per l'ottimizzazione ai minimi quadrati paralleli, magari trovi anche implementazioni già pronte. Una volta che hai l'algoritmo, l'altro problema è l'implementazione (anche questo non banalissimo). Ciao Manlio -BEGIN PGP SIGNATURE- Version: GnuPG v1.4.10 (GNU/Linux) Comment: Using GnuPG with Mozilla - http://enigmail.mozdev.org/ iEYEARECAAYFAk7FR/UACgkQscQJ24LbaUQWyQCaAwJJ3RG49Tavy19BBSRDvXl3 9P0An1g1oS7rfLK4quLwRXUvsFqbXfEz =UcKu -END PGP SIGNATURE- ___ Python mailing list Python@lists.python.it http://lists.python.it/mailman/listinfo/python
Re: [Python] Utilizzo completo della cpu
2011/11/17 Matteo Perini perini.mat...@gmail.com: Ciao lista, ciao Matteo, Vorrei sapere se è possibile utilizzare tutti i core della cpu per eseguire calcoli gravosi. Per usare tutti i core devi usare il modulo multiprocessing (incluso nella libreria dalla 2.7), l'API è simile a quella del modulo threading. ciao -- Gian Mario Tagliaretti GNOME Foundation member gia...@gnome.org ___ Python mailing list Python@lists.python.it http://lists.python.it/mailman/listinfo/python
Re: [Python] Utilizzo completo della cpu
On Thu, 17 Nov 2011 17:19:12 +0100, Matteo Perini perini.mat...@gmail.com wrote: Ciao lista, Vorrei sapere se è possibile utilizzare tutti i core della cpu per eseguire calcoli gravosi. Ho guardato un po' in internet e come risposta ho trovato il multithreading che ho già utilizzato un paio di volte. Però non riesco a capire se è possibile applicarlo anche ad un unico comando. Non credo nel tuo caso. Il codice python in linea di massima non può essere eseguito in multithread, nel senso che l'interprete può esegure un solo opcode alla volta. Ma se questo opcode è lungo di suo, per esempio legge da un file, o dalla rete, o fa qualcosa di complesso ma restando in C, senza toccare pezzi di python, allora può rilasciare il GIL e permettere ad altri thread di correre in parallelo. Di conseguenza, un programma python può beneficiare di multithread solo quando è IO-bound, non quando è CPU-bound, e il tempo di CPU è speso in codice Python. Nota che - se ricordo bene - numpy rilascia il GIL per le operazioni implementate in C, ovvero, se fai A + B dove A e B sono matrici 1 x 1, mentre le somma può permettere ad altro codice (python o meno) di correre. Ma la funzione leastsq, anche se è scritta in C, valuta continuamente la fp che, essendo scritta in Python, ha bisogno di aspettare il GIL per essere eseguita. Al di là della prestazione di Python coi thread, non credo che la leastsq sia parallelizzabile: se non dico cappellate, l'algoritmo consiste in valutare continuamente la funzione in un numero di punti e ogni valutazione ha bisogno dei risultati precedenti, quindi non mi sembra un problema adatto ad essere parallelizzato. -- Daniele Varrazzo - Develer S.r.l. http://www.develer.com ___ Python mailing list Python@lists.python.it http://lists.python.it/mailman/listinfo/python
Re: [Python] Utilizzo completo della cpu
-BEGIN PGP SIGNED MESSAGE- Hash: SHA1 Il 17/11/2011 17:19, Matteo Perini ha scritto: Ciao lista, Vorrei sapere se è possibile utilizzare tutti i core della cpu per eseguire calcoli gravosi. Ho guardato un po' in internet e come risposta ho trovato il multithreading che ho già utilizzato un paio di volte. Però non riesco a capire se è possibile applicarlo anche ad un unico comando. Mi spiego meglio. ho una funzione fp non lineare che deve essere ottimizzata... fp = lambda v, x,y, phi:(1+v[0]*phi+v[1]*x+v[2]*x*phi+v[3]*y+v[4]*y*phi+v[5]*x**2... +v[6]*phi*x**2+v[7]*y**2+v[8]*phi*y**2+v[9]*x*y+v[10]*phi*x*y)/(v[11]+v[12]*phi... +v[13]*x+v[14]*x*phi+v[15]*y+v[16]*y*phi+v[17]*x**2+v[18]*phi*x**2+v[19]*y**2... +v[20]*phi*y**2+v[21]*x*y+v[22]*phi*x*y) Prima che ti complichi la vita con una implementazione parallela, ti consiglio di ottimizzare l'implementazione attuale. In particolare, nella definizione di fp vedo *molti* termini che sono calcolati ripetutamente, mentre possono essere pre-calcolati una sola volta. Magari un compilatore C efficiente è in grado di ottimizzare i termini comuni, ma non CPython. [...] Ciao Manlio -BEGIN PGP SIGNATURE- Version: GnuPG v1.4.10 (GNU/Linux) Comment: Using GnuPG with Mozilla - http://enigmail.mozdev.org/ iEYEARECAAYFAk7FS7MACgkQscQJ24LbaUSqegCfUDt74UmB2tFwF4enDtJdXP30 jxYAmwRygA9IePrjxI6r+GwiaXDT7B/n =mTtp -END PGP SIGNATURE- ___ Python mailing list Python@lists.python.it http://lists.python.it/mailman/listinfo/python
Re: [Python] Utilizzo completo della cpu
-BEGIN PGP SIGNED MESSAGE- Hash: SHA1 Il 17/11/2011 18:50, Daniele Varrazzo ha scritto: On Thu, 17 Nov 2011 17:19:12 +0100, Matteo Perini [...] Al di là della prestazione di Python coi thread, non credo che la leastsq sia parallelizzabile: se non dico cappellate, l'algoritmo consiste in valutare continuamente la funzione in un numero di punti e ogni valutazione ha bisogno dei risultati precedenti, quindi non mi sembra un problema adatto ad essere parallelizzato. Se la funzione è semplice, si può ottimizzare il tutto. Ad esempio: http://it.wikipedia.org/wiki/Metodo_dei_minimi_quadrati nel caso in cui la funzione obbiettivo sia una retta. In questo caso la parallelizzazione è banale. Anche il caso di funzione lineare dovrebbe essere possibile da parallelizzare (per curiosità ho cercato ed ho trovato un paper in cui veniva descritta una implementazione che utilizzava le versioni parallele di BLAS e Lapack). Nel caso di Matteo, il codice della funzione non è ben leggibile e non riesco a capire, a vista, di che tipo di funzione si tratti (se è lineare o non lineare). Ciao Manlio -BEGIN PGP SIGNATURE- Version: GnuPG v1.4.10 (GNU/Linux) Comment: Using GnuPG with Mozilla - http://enigmail.mozdev.org/ iEYEARECAAYFAk7FTlcACgkQscQJ24LbaUQHpQCfeHZIO3VqcXBVvh6/acSNiGcB D1IAn3heG4jCm1QvNlhIryQCxwA4FRbM =NVcJ -END PGP SIGNATURE- ___ Python mailing list Python@lists.python.it http://lists.python.it/mailman/listinfo/python
Re: [Python] Utilizzo completo della cpu
Matteo, oggi ti tempesto... Io non so nulla di calcolo su più core, ma faccio molto i minimi quadrati. Se ti interessa sto sviluppando un sistema semplice per fare tutto da riga di comando, lo trovi qui: https://github.com/gdurin/pyFitting Grazie, ho dato un occhiata veloce ma devo studiarmelo un po' Non sono un informatico/programmatore di professione. Se ho problemi chiedo!?!? ;) la cosa che ti potrebbe aiutare potrebbe essere utilizzare le derivate analitiche (il mio parametro -d), che diminuiscono sensibilmente il numero di passi da far fare alla routine. Oppure prendi spunto per farlo tu (ho usato sympy e numexpr per compilare e ottimizzare il calcolo) Per ogni dettaglio puoi vedere qui in un talk che ho fatto di recente: http://emma.inrim.it:8080/gdurin/talks/fit-the-elefant-on-the-use-of-least-square-methods-from-simple-cases-to-multiparameter-scaling-functions/ Certo, fittare con 22 parametri è un bel problema, ed è proprio fittare un elefante (che pare abbia bisogno di 'soli' 13 parametri). Un problema noto è che spesso molti sistemi (le funzioni teoriche) sono 'sloppy', cioé poco sensibili alle variazioni anche ampie dei parametri. Quindi il fit non si muove mai, soprattutto se hai le derivate (per il calcolo dello jacobiano) numeriche. Inoltre di solito è un casino decidere i valori iniziali, soprattutto nel tuo caso (so che qualcuno usa degli algoritmi genetici per la stima dei valori iniziali, ma non ne so molto). Solitamente inserisco i valori trovati dal tentativo precedente. Questo aiuta un po' Cose biologiche? ciao Gianfranco Ciao Grazie ___ Python mailing list Python@lists.python.it http://lists.python.it/mailman/listinfo/python
Re: [Python] Utilizzo completo della cpu
Il 17/11/2011 18:44, Manlio Perillo ha scritto: -BEGIN PGP SIGNED MESSAGE- Hash: SHA1 Il 17/11/2011 17:19, Matteo Perini ha scritto: Ciao lista, Vorrei sapere se è possibile utilizzare tutti i core della cpu per eseguire calcoli gravosi. Si. Come è possibile usare anche tutte le cpu dei computer in una rete. Il come è un altro discorso... Ho guardato un po' in internet e come risposta ho trovato il multithreading che ho già utilizzato un paio di volte. Il multithreading in Python non va bene, a meno di condizioni particolari (cerca su Internet Python GIL). Grazie del consiglio. Però non riesco a capire se è possibile applicarlo anche ad un unico comando. Che intendi come comando? Scusami ma non conosco la terminologia corretta Io per comando intendevo leastsq(e, v0, args=(x,y,phi,z), maxfev=1) Mi spiego meglio. ho una funzione fp non lineare che deve essere ottimizzata... fp = lambda v, x,y, phi:(1+v[0]*phi+v[1]*x+v[2]*x*phi+v[3]*y+v[4]*y*phi+v[5]*x**2... +v[6]*phi*x**2+v[7]*y**2+v[8]*phi*y**2+v[9]*x*y+v[10]*phi*x*y)/(v[11]+v[12]*phi... +v[13]*x+v[14]*x*phi+v[15]*y+v[16]*y*phi+v[17]*x**2+v[18]*phi*x**2+v[19]*y**2... +v[20]*phi*y**2+v[21]*x*y+v[22]*phi*x*y) Scusa, ma perchè usi lambda? Nel tuo caso rende il codice meno leggibile. Fai un più semplice: def fp(v, x, y, phi): ... Le lambda dovrebbero essere usate *solo* se ti serve una funzione anonima (ad esempio per passarla come argomento ad un altra funzione). Ho trovato un paio di esempi on-line, nonche sul sito ufficiale che usavano sempre lambda per passare la funzione a leastsq http://www.scipy.org/scipy_Example_List#head-4c436ae0085d9a56056425d11abff4ccdd3d3620 Quindi ho usato quella. Se ho capito bene potrei usare: def fp(v, x, y, phi): return (1+v[0]*phi+v[1]*x+v[2]*x*phi+v[3]*y+v[4]*y*phi+v[5]*x**2... +v[6]*phi*x**2+v[7]*y**2+v[8]*phi*y**2+v[9]*x*y+v[10]*phi*x*y)/(v[11]+v[12]*phi... +v[13]*x+v[14]*x*phi+v[15]*y+v[16]*y*phi+v[17]*x**2+v[18]*phi*x**2+v[19]*y**2... +v[20]*phi*y**2+v[21]*x*y+v[22]*phi*x*y) Giusto? Devi parallelizzare l'algoritmo, e di solito non è banale. In letteratura dovresti trovare algoritmi per l'ottimizzazione ai minimi quadrati paralleli, magari trovi anche implementazioni già pronte. Una volta che hai l'algoritmo, l'altro problema è l'implementazione (anche questo non banalissimo). Mmmm la vedo mooolto dura per le mie conoscenze. Grazie dei consigli Matteo ___ Python mailing list Python@lists.python.it http://lists.python.it/mailman/listinfo/python
Re: [Python] Utilizzo completo della cpu
Il 17/11/2011 18:44, Gian Mario Tagliaretti ha scritto: 2011/11/17 Matteo Periniperini.mat...@gmail.com: Ciao lista, ciao Matteo, Vorrei sapere se è possibile utilizzare tutti i core della cpu per eseguire calcoli gravosi. Per usare tutti i core devi usare il modulo multiprocessing (incluso nella libreria dalla 2.7), l'API è simile a quella del modulo threading. ciao Molto interessante questa cosa... proverò a studiarmelo e a fare qualche prova. Grazie Matteo ___ Python mailing list Python@lists.python.it http://lists.python.it/mailman/listinfo/python
