Visualizza post

Questa sezione ti permette di visualizzare tutti i post inviati da questo utente. N.B: puoi vedere solo i post relativi alle aree dove hai l'accesso.


Topics - GlennHK

Pagine: 1 2 [3] 4
31
Python-it.org cafè / Quando __slots__ ti salva la vita...
« il: Marzo 17, 2014, 12:22 »
Girovagando sulla rete ho trovato questa roba:

http://tech.oyster.com/save-ram-with-python-slots/

possibile che 6 GB di RAM erano occupati solo da dizionari Python?  :question:

32
Progetti e script / N-regine e CSP
« il: Marzo 14, 2014, 12:01 »
Leggendo l'AIMA, mi ha incuriosito il capitolo sul CSP e in particolare l'algoritmo min-conflicts, quindi ho deciso di applicarlo al problema delle N-regine ed è venuto fuori questo: http://davidecanton.wordpress.com/2014/02/14/min-conflicts-vs-n-regine/.

Devo dire che come prestazioni mi ha soddisfatto abbastanza, se a qualcuno interessa leggerlo o ha sviluppato qualcosa di migliore, mi piacerebbe avere qualche parere, visto che l'IA mi ha sempre affascinato particolarmente.

EDIT: è questa la sezione giusta? Se non lo è, spostate pure il thread.

33
Ciao a tutti!

Sto impazzendo dietro a un problema: devo trasformare una funzione ricorsiva in iterativa per problemi prestazionali, ma non riesco a trovare un modo per effettuare la conversione, forse sono un po' rimbambito (e arrugginito ;) ). Qualcuno ha un'idea su un abbozzo di conversione?

La funzione è riportata di seguito:

[codice]
def _jump(self, current, direction, goal):
        next = current + direction
        if self.labirinth[next] == 0 or next not in self.labirinth:
            return None
        if np.array_equal(next, goal):
            return next
        isDiag = direction.all()
        if isDiag:
            if all(self.labirinth[current + dirs] == 0
                   for dirs in components(direction)):
                return None
            forced = self.compute_forcedDiag(current, direction)
        else:
            forced = self.compute_forcedStraight(next, direction)
        if any(self.labirinth[f] == 1 for f in forced):
            return next
        if isDiag:
            for dirt in components(direction):
                if self._jump(next, dirt, goal) is not None:
                    return next
        return self._jump(next, direction, goal)
[/codice]

34
Altre tematiche / Eclipse + PyDev si blocca con Code Analysis
« il: Ottobre 10, 2013, 00:40 »
Ciao a tutti! Sto cercando di configurare PyDev con Eclipse, creo un progetto vuoto, creo un file vuoto e parte la "Code Analysis". Purtroppo Eclipse a questo punto si blocca, e non risponde più, devo terminarlo con la forza. A qualcuno è capitato? Sapete come risolvere?

Uso Kubuntu 13.04, 64-bit e Eclipse Juno

35
Ciao a tutti! Oggi propongo un'implementazione semplice di un automa a stati finiti che usa lo State Pattern. Posto il link alla gist, i suggerimenti sono sempre accetti!

https://gist.github.com/DavideCanton/5943656

36
Base / Runtime Error usando i Manager con multiprocessing
« il: Giugno 04, 2013, 19:50 »
Ciao a tutti, sto cercando di parallelizzare le simulazioni di un solitario di carte usando multiprocessing.Pool, e mi serve contare quante volte è uscito il solitario. Poichè il valore è condiviso, mi è sembrato naturale wrapparlo in un manager di tipo Value, come riportato nel listato:

[codice]
import numpy as np
import numpy.random as nprand
import multiprocessing as mp

def simula(usciti):
    num = np.tile(np.arange(1, 11), 4)
    num = nprand.permutation(num)
    for i in range(3):
        if len((num[i::3] == i + 1).nonzero()[0]):
            return
    else:
        usciti.value += 1


if __name__ == '__main__':
    max_t = 1000000
    usciti = mp.Value('i', 0)
    p = mp.Pool(mp.cpu_count() * 2)

    for _ in range(max_t):
        p.apply_async(simula, args=[usciti])

    p.close()
    p.join()

    print("Uscito", usciti.value, "volte su", max_t)

[/codice]

Purtoppo mi viene riportato l'errore "RuntimeError: Synchronized objects should only be shared between processes through inheritance". Solo che nella documentazione non ho trovato nulla a riguardo di quest'errore, qualcuno che ha più esperienza di me con mp ha qualche idea a riguardo?

37
Altre tematiche / 7 librerie carine per Python
« il: Maggio 24, 2013, 13:53 »
Ciao a tutti! Oggi girovagando su G+ ho trovato quest'articolo:

http://www.lleess.com/2013/03/7-python-libraries-you-should-know-about.html?m=1

Che ne pensate?

38
Ciao a tutti!
Sto cercando tramite numpy e la sua implementazione della FFT di ottenere da una canzone la sua Trasformata di Fourier, che la trasporta nel dominio delle frequenze. Creare un gigantesco array e applicarci np.fft.fft mi va bene per canzoni piccole e per ottenere uno spettro completo, ma se io volessi, ad esempio, visualizzare un piccolo istogramma dinamicamente mentre riproduco la canzone, che approccio dovrei seguire? (Per chi non ha un'idea in mente, intendo le barre di un qualsiasi riproduttore mp3 o di audacity...)

40
Calcolo scientifico / Creazione matrici Numpy + Cvxopt
« il: Gennaio 29, 2013, 15:55 »
Ciao a tutti, stiamo realizzando un progetto per l'università con la mia ragazza e devo utilizzare numpy per gestire delle matrici di dimensioni relativamente grandi (ho un problema da affrontare che è O(2^n) in spazio). In ogni iterazione devo generare una parte matrice dei vincoli per un problema di ottimizzazione lineare mentre l'altra parte dev'essere aggiornata ad ogni iterazione. In pseudocodice:

[codice]
A = generaMatrice()
X = aggiornaMatrice(X)
soluzione = risolvi(A, b, X, xb)
[/codice]

Per la generazione della matrice A il modo migliore che abbiamo trovato è di generare una matrice di zeri e mano mano inserire i valori con un ciclo (lo so che i cicli in NumPy sono sconsigliati, ma non ho trovato altro modo), mentre per l'aggiornamento della matrice X ho dovuto fare un accrocchio simile:
[codice]
m = []
for bla bla bla:
      m.append(row)
return np.vstack([X, np.array(m)])
[/codice]

Esiste un modo migliore? (Ho visto che c'è np.append per gli array ma ogni volta ne crea uno nuovo e non è in place...).

Inoltre avrei un altro quesito, la libreria che uso per la risoluzione dei problemi di programmazione lineare si chiama cvxopt, e le matrici che vuole in input sono in column-major order (presumo perchè hanno a che fare col Fortran) mentre quelle di NumPy sono per righe e devo fare una cosa così:

[codice]
def solve(A, b, X, bx, opt):
    G = cvxopt.matrix(np.vstack([A, X]))
    h = cvxopt.matrix(np.hstack([b, bx]))
    c = cvxopt.matrix(opt)
    return cvxopt.solvers.lp(c, G, h)
[/codice]
con conseguente raddoppio dello spazio occupato. Qualcuno ha qualche idea su come migliorare?

41
Ciao a tutti. Da poco ho iniziato ad usare Firefox sul mio cellulare android e ho notato che in alcuni post il font è più grande che in altri mentre con altri browser no.. Any known issue?

42
Base / Limitare import
« il: Dicembre 23, 2012, 17:20 »
Ciao a tutti, probabilmente la domanda che faccio è banale ma ho un dubbio:

ho un package pyIA in cui ho un file __init__.py che contiene:

[codice]
__all__ = ["logic", "reductions", "sat", "searching"]
[/codice]

La struttura della cartella è semplice:
pyIA
+----__init__.py
+----logic.py
+----reductions.py
+----sat.py
+----searching.py

In ogni file ho definito una variabile __all__, ad esempio in logic.py:

[codice]
from functools import total_ordering, reduce
from operator import and_
import itertools as it
from random import randint, choice, sample, random
import re
from collections import defaultdict

__all__ = ["Clause", "Formula", "Variable", "build_formula",
           "randomFormula", "randomHornFormula"]

# eccetera
[/codice]

Se io eseguo
[codice]
from pyIA import *
[/codice]
nell'interprete mi importa i 4 sottomoduli, ma anche roba come logic.defaultdict e altre cose che ho importato, pur avendo specificato __all__! E' possibile evitare questo (perchè __all__ l'ho specificato apposta e con cose come from pyIA.logic import * funziona)?

43
Progetti e script / Scriptino per cambiare l'IP della connessione
« il: Dicembre 17, 2012, 18:53 »
Salve a tutti, ho realizzato un piccolo script con python 3.2 (ma adattabile tranquillamente a python 2.x) per la modifica dell'assegnamento dell'IP al proprio PC. Per ora supporta solo Windows tramite WMI, prossimanente aggiungerò anche il supporto a Linux  ;)

[codice]
'''
Created on 7/dic/2012

@author: davide
'''
from tkinter.tix import Tk
from tkinter.ttk import Label, Entry, Button
import sys
from tkinter.messagebox import showerror
from tkinter import StringVar
try:
    from wmi import WMI
except ImportError:
    pass

from functools import partial, wraps


class IPError(Exception):
    def __init__(self, msg):
        super(IPError, self).__init__(msg)


class IPManager:
    def setStatic(self, ip, gateway, mask="/24"):
        raise NotImplemented

    def setDynamic(self):
        raise NotImplemented

    def getData(self):
        raise NotImplemented


class IPManagerWin(IPManager):
    query = ("select * from "
            "Win32_NetworkAdapterConfiguration where IPEnabled=TRUE")

    def __init__(self):
        wmi = WMI()
        net_adapter = wmi.Win32_NetworkAdapterConfiguration(IPEnabled=True)
        if not net_adapter:
            raise IPError("Adapter not found")
        self.ni = net_adapter[0]
        self.wmi = wmi

    def _split(self, l, n):
        it = iter(l)
        while True:
            try:
                yield "".join([next(it) for _ in range(n)])
            except StopIteration:
                break

    def _expand(self, mask):
        i = int(mask[1:])
        s = "1" * i + "0" * (32 - i)
        b2 = partial(int, base=2)
        return ".".join(str(b2(x)) for x in self._split(s, 8))

    def setStatic(self, ip, gateway, mask="/24"):
        if mask[0] == "/":
            mask = self._expand(mask)
        v, *_ = self.ni.EnableStatic(IPAddress=[ip],
                                     SubnetMask=[mask])
        if v != 0:
            raise IPError("Errore in EnableStatic: {}".format(v))
        v, *_ = self.ni.SetGateways(DefaultIPGateway=[gateway])
        if v != 0:
            raise IPError("Errore in SetGateways: {}".format(v))

    def setDynamic(self):
        v, *_ = self.ni.EnableDHCP()
        if v != 0:
            raise IPError("Errore in EnableDHCP: {}".format(v))

    def getData(self):
        res = self.wmi.query(IPManagerWin.query)
        dev = res[0]
        return (dev.IPAddress[0], dev.IPSubnet[0],
                dev.DefaultIPGateway[0], dev.DHCPEnabled)


class IPManagerLinux(IPManager):
    # TODO
    pass


class Show_error_in_messagebox:
    def __init__(self, exctypes, aft_raise=False):
        self.exctypes = exctypes
        self.aft_raise = aft_raise

    def __call__(self, func):
        @wraps(func)
        def wrapper(*a, **k):
            try:
                ret = func(*a, **k)
            except Exception as e:
                if type(e) in self.exctypes:
                    showerror("Errore", str(e))
                    if self.aft_raise:
                        raise e
                    else:
                        return
                else:
                    raise e
            return ret
        return wrapper


class GUI(Tk):
    @Show_error_in_messagebox([IPError], aft_raise=True)
    def __init__(self, master=None):
        super(GUI, self).__init__(master)
        self.title("IP Manager")
        self.ip = StringVar()
        self.mask = StringVar()
        self.gateway = StringVar()
        Label(self, text="IP:").grid(row=0, column=0)
        Entry(self, textvar=self.ip).grid(row=0, column=1)
        Label(self, text="Mask:").grid(row=1, column=0)
        Entry(self, textvar=self.mask).grid(row=1, column=1)
        Label(self, text="Gateway:").grid(row=2, column=0)
        Entry(self, textvar=self.gateway).grid(row=2, column=1)
        bs = Button(self, text="IP Statico", command=self.ip_static)
        bs.grid(row=3, column=0)
        bd = Button(self, text="IP Dinamico", command=self.ip_dynamic)
        bd.grid(row=3, column=1)
        bu = Button(self, text="Aggiorna", command=self._fillData)
        bu.grid(row=4, column=0, columnspan=2)
        self.ipm = self._getManager()
        self.status = Label(self)
        self.status.grid(row=5, column=0, columnspan=2)
        self._fillData()

    def _fillData(self):
        ip, mask, gateway, dynamic = self.ipm.getData()
        self.ip.set(ip)
        self.mask.set(mask)
        self.gateway.set(gateway)
        if dynamic:
            self.status.configure(text="IP Dinamico")
        else:
            self.status.configure(text="IP Statico")

    def _getManager(self):
        if sys.platform.startswith("win32"):
            return IPManagerWin()
        else:
            return IPManagerLinux()

    @Show_error_in_messagebox([IPError])
    def ip_static(self):
        ip = self.ip.get()
        mask = self.mask.get()
        gateway = self.gateway.get()
        if ip and mask and gateway:
            self.ipm.setStatic(ip, gateway, mask)
            self.status.configure(text="IP Statico")
            self._fillData()

    @Show_error_in_messagebox([IPError])
    def ip_dynamic(self):
        self.ipm.setDynamic()
        self.status.configure(text="IP Dinamico")
        self._fillData()


if __name__ == '__main__':
    GUI().mainloop()

[/codice]

44
Base / Depth first a sinistra in template method
« il: Ottobre 22, 2012, 23:04 »
Ciao a tutti!

Sto implementando dei metodi per la visita di alberi di ricerca, e in particolare ho implementato le visite breadth-first e depth-first usando il pattern Template Method riadattato. Il mio problema è che, per come ho implementato la ricerca depth-first, essa preferisce visitare i figli del nodo da destra verso sinistra (in quanto la lista dei nodi visitati è uno stack). Vorrei sapere se a qualcuno di voi viene un'ideuzza su come implementare la funzione depth-first a sinistra (possibilmente senza modificare l'algoritmo template).

Posto il codice:

[codice]
@total_ordering
class Node:
    def __init__(self, content, parent=None, value=0, depth=0):
        self.content = content
        self.value = value
        self.depth = depth
        self.parent = parent

    def __eq__(self, val):
        return self.value == val.value

    def __lt__(self, val):
        return self.value < val.value

    def __repr__(self):
        return ("<Node, cnt: {}, val: {}, dpt: {}>"
                .format(self.content, self.value, self.depth))


class Info:
    def __init__(self, maxl=0, nodes=0):
        self.maxl = maxl
        self.nodes = nodes

    def __repr__(self):
        return (r"Info[Max Length: {}, Nodes processed: {}]"
                .format(self.maxl, self.nodes))

# visita generica
def generic_search(start, is_goal, gen_children,
                   L, get_func, put_func):

    put_func(L, Node(start))
    info = Info()
    visited = set()

    while L:

        info.maxl = max(len(L), info.maxl)
        info.nodes += 1

        current = get_func(L)

        if is_goal(current.content):
            n = current
            pc = []
            while n:
                pc.append(n.content)
                n = n.parent
            pc.reverse()
            return pc, info

        visited.add(current.content)

        for child in gen_children(current.content):
            if child in visited:
                continue
            x = Node(child, current)
            x.depth = current.depth + 1
            put_func(L, x)

    return None, info


def depth_first(start, is_goal, gen_children):
    push = lambda l, n: l.append(n)
    return generic_search(start, is_goal, gen_children,
                          [], list.pop, push)


def breadth_first(start, is_goal, gen_children):
    dequeue = lambda l: l.pop(0)
    enqueue = lambda l, n: l.append(n)
    return generic_search(start, is_goal, gen_children,
                          [], dequeue, enqueue)
[/codice]

EDIT: mancavano le classi definite sopra

45
Base / Priority Queue non completamente in RAM
« il: Ottobre 11, 2012, 15:34 »
Ciao a tutti!

Ho implementato l'algoritmo di ricerca A* per il corso di intelligenza artificiale e nella ricerca per mantenere la lista dei nodi ordinata ho utilizzato il modulo heapq. Inoltre ho applicato l'algoritmo alla ricerca di un path in un labirinto espresso come immagine binaria. L'algoritmo è corretto ma la sua complessità spaziale per immagini grandi mi crea problemi tipo MemoryError. Volevo sapere se sc'è un qualche modo di gestire la lista ad heap in modo che solo una parte di essa sia in memoria (in quanto l'estrazione dalla lista mi serve solo del minimo).

Pagine: 1 2 [3] 4