python Archivi - Petar Karan

12 Ottobre 2022 Nessun commento

[python] Classe in Python per accedere con pyodbc ad un database MS Access

Vediamo un semplice esempio di una classe costruita in Python per accedere ad un database MS Access (*.mdb, *.accdb) utilizzando la libreria pyodbc.

Anzitutto procuriamoci pyodbc utilizzando PIP

pip install pyodbc

1	pip install pyodbc

Creiamo la nostra classe nella maniera seguente (nel mio caso creerò un file chiamato accessdb.py):

import pyodbc

class AccessDB():

    def __init__(s,cs):
        s.__cs = cs
        s.__conn = None

        s.__connect()

    def __connect(s):
        s.__conn = pyodbc.connect(s.__cs)

    def In(s,sql,*vals):
        cursor = s.__conn.cursor()
        cursor.execute(sql,vals)
        cursor.execute("SELECT @@IDENTITY")
        lastid = cursor.fetchone()[0]
        s.__conn.commit()
        return lastid

    def Out(s,sql,*vals):
        cursor = s.__conn.cursor()
        cursor.execute(sql,vals)
        risultato = []
        for riga in cursor.fetchall():
            tmp = {}
            for i, col in enumerate(cursor.description):
                tmp[col[0]] = riga[i]
            risultato.append(tmp)
        return risultato

    def __del__(s):
        s.__conn.close()

import pyodbc

class AccessDB():

def __init__(s,cs):

s.__cs = cs

s.__conn = None

s.__connect()

def __connect(s):

s.__conn = pyodbc.connect(s.__cs)

def In(s,sql,*vals):

cursor = s.__conn.cursor()

cursor.execute(sql,vals)

cursor.execute("SELECT @@IDENTITY")

lastid = cursor.fetchone()[0]

s.__conn.commit()

return lastid

def Out(s,sql,*vals):

cursor = s.__conn.cursor()

cursor.execute(sql,vals)

risultato = []

for riga in cursor.fetchall():

tmp = {}

for i, col in enumerate(cursor.description):

tmp[col[0]] = riga[i]

risultato.append(tmp)

return risultato

def __del__(s):

s.__conn.close()

Il metodo In restituisce, se presente, l’ultimo ID inserito. Il metodo Out restituisce una lista di dizionari, con i nomi delle colonne e i valori per ogni riga.

Immaginiamo di posizionare il suddetto file in una sottocartella librerie.

Possiamo usare la classe nella maniera seguente:

from librerie.accessdb import AccessDB


db = AccessDB(r'Driver={Microsoft Access Driver (*.mdb, *.accdb)};DBQ=C:\cartella del database\scuola.accdb')

sid = db.In("INSERT INTO studenti (nome,cognome) VALUES('Zeno','Neri')")

print(sid)

studenti = db.Out("SELECT * FROM studenti")

print(studenti)

for s in studenti:
    print(s["nome"])


del db

from librerie.accessdb import AccessDB

db = AccessDB(r'Driver={Microsoft Access Driver (*.mdb, *.accdb)};DBQ=C:\cartella del database\scuola.accdb')

sid = db.In("INSERT INTO studenti (nome,cognome) VALUES('Zeno','Neri')")

print(sid)

studenti = db.Out("SELECT * FROM studenti")

print(studenti)

for s in studenti:

print(s["nome"])

del db

ATTENZIONE! Nella stringa di connessione va inserito il percorso assoluto del file del database.

Vedi articolo

18 Settembre 2021 Nessun commento

[python] Disegnare matrice concentrica in Python data una dimensione arbitraria (e valutare le prestazioni)

Vogliamo scrivere un algoritmo in Python che, dato un lato n-esimo arbitrario, disegni una matrice di valori concentrici. Il risultato che vogliamo ottenere è il seguente:

Questo problema ha molteplici soluzioni e Python ne permette un’estrema sintesi.

Cominciamo dalla soluzione più semplice, ma che richiede il maggior numero di cicli.

Anzitutto calcoliamo la dimensione del quadrato:

n = int(input("lato: "))
dim = n*2-1

1 2	n = int(input("lato: ")) dim = n*2-1

Adesso prepariamo una matrice di dimensione dim fatta di soli 0

m = [[0 for j in range(dim)] for i in range(dim)]

1	m = [[0 for j in range(dim)] for i in range(dim)]

Il procedimento che seguiremo ora sarà quello di stringere la matrice sempre di più, ridisegnando i vari quadrati all’interno della matrice di 0 appena creata.

for k in range(n):
    for i in range(k,dim-k):
        for j in range(k,dim-k):
            m[i][j] = n - k

for k in range(n):

for i in range(k,dim-k):

for j in range(k,dim-k):

m[i][j] = n - k

In questo modo disegneremo ad ogni passaggio un quadrato di numeri n-k

Stampiamo infine a video la matrice:

for r in m:
    for c in r:
        print(c,end=" ")
    print()

for r in m:

for c in r:

print(c,end=" ")

print()

Possiamo misurare il tempo di calcolo necessario (questo tempo dipende principalmente dal processore in uso, quindi varia da macchina a macchina) utilizzando la libreria time

Il codice diventerebbe il seguente:

import time

n = int(input("lato: "))
dim = n*2-1

start = time.time()

m = [[0 for j in range(dim)] for i in range(dim)]

for k in range(n):
    for i in range(k,dim-k):
        for j in range(k,dim-k):
            m[i][j] = n - k

end = time.time()

print("%s secondi" %(end-start))

import time

n = int(input("lato: "))

dim = n*2-1

start = time.time()

m = [[0 for j in range(dim)] for i in range(dim)]

for k in range(n):

for i in range(k,dim-k):

for j in range(k,dim-k):

m[i][j] = n - k

end = time.time()

print("%s secondi" %(end-start))

Nel mio caso l’operazione per un lato di dimensione 1000 impiega circa 131.700 ms. Su questo torneremo successivamente.

Possiamo però riscrivere l’algoritmo in un altra forma più sintetica.

import time

n = int(input("lato: "))
dim = n*2-1

start = time.time()

def v(i,j):
    i = i if i < dim / 2 else dim - i - 1
    j = j if j < dim / 2 else dim - j - 1
    return n - (j if j <= i else i)

m = [[v(i,j) for j in range(dim)] for i in range(dim)]

end = time.time()

import time

n = int(input("lato: "))

dim = n*2-1

start = time.time()

def v(i,j):

i = i if i < dim / 2 else dim - i - 1

j = j if j < dim / 2 else dim - j - 1

return n - (j if j <= i else i)

m = [[v(i,j) for j in range(dim)] for i in range(dim)]

end = time.time()

Questa volta l’algoritmo impiega 1.250 ms circa, sempre per lato di dimensione 1000.

Il risultato è il medesimo, ma il tempo di calcolo è decisamente inferiore.

Un’altra versione potrebbe essere la seguente:

import time

n = int(input("lato: "))
dim = 2*n-1

start = time.time()

m = [[0 for i in range(dim)] for j in range(dim)]

for i in range(n):
    for j in range(i, dim-i):
        m[i][j] = n
        m[dim-i-1][j] = n
        m[j][i] = n
        m[j][dim-i-1] = n
    n -= 1

end = time.time()

import time

n = int(input("lato: "))

dim = 2*n-1

start = time.time()

m = [[0 for i in range(dim)] for j in range(dim)]

for i in range(n):

for j in range(i, dim-i):

m[i][j] = n

m[dim-i-1][j] = n

m[j][i] = n

m[j][dim-i-1] = n

n -= 1

end = time.time()

Questa volta il tempo di calcolo, per dimensione 1000 di lato, è di circa 490 ms.

Confrontando i tre algoritmi su range di calcoli da 50 a 1000, otteniamo le seguenti performance (il primo algoritmo lo chiamiamo A, l’ultimo lo chiamiamo C):

Che possiamo mettere in un grafico (con scala logaritmica) come il seguente:

Vedi articolo

8 Maggio 2021 Nessun commento

[python] Albero binario in Python

Riporto qui un classico dell’informatica di base: la realizzazione di un albero binario per l’ordinamento.

Quello dell’albero binario è un algoritmo che consente di ordinare dei valori in base al criterio di inserimento e successivamente di lettura.

Per far capire meglio il procedimento vediamo anzitutto come funziona.

Immaginiamo di avere la sequenza di numeri 3, 4, 1, 7, 6, 5, 8, 11, 9. L’algoritmo prevede la creazione di una struttura ad albero, composta di nodi, dove ogni nodo contiene un valore e un ramo di sinistra e uno di destra, che puntano rispettivamente al valore minore e maggiore, rispetto al valore nel nodo. La creazione dell’albero procederà quindi come nel video soprastante.

La lettura avverrà invece a partire dal primo nodo, procedendo anzitutto sul nodo di sinistra, poi stampando il valore del nodo corrente e poi procedendo sul nodo di destra. Come illustrato nella seguente animazione:

Procedendo in questo modo otterremo tutti i valori ordinati.

Questo algoritmo può essere scritto in Python nel modo seguente:

class Nodo:
    def __init__(s,v = None):
        s.valore = v
        s.sx = s.dx = None

def aggiungi(nodo,v):
    if nodo.valore is None:
        nodo.valore = v
        nodo.sx = Nodo()
        nodo.dx = Nodo()
    elif v < nodo.valore:
        aggiungi(nodo.sx,v)
    else:
        aggiungi(nodo.dx,v)

def stampa(nodo):
    if nodo.valore is not None:
        stampa(nodo.sx)
        print(nodo.valore)
        stampa(nodo.dx)

radice = Nodo()


numeri = [3,2,7,4,6,5,9,10]
for n in numeri:
    aggiungi(radice,n)

stampa(radice)

class Nodo:

def __init__(s,v = None):

s.valore = v

s.sx = s.dx = None

def aggiungi(nodo,v):

if nodo.valore is None:

nodo.valore = v

nodo.sx = Nodo()

nodo.dx = Nodo()

elif v < nodo.valore:

aggiungi(nodo.sx,v)

else:

aggiungi(nodo.dx,v)

def stampa(nodo):

if nodo.valore is not None:

stampa(nodo.sx)

print(nodo.valore)

stampa(nodo.dx)

radice = Nodo()

numeri = [3,2,7,4,6,5,9,10]

for n in numeri:

aggiungi(radice,n)

stampa(radice)

Vedi articolo

23 Aprile 2021 Nessun commento

[python] Semplice simulazione dell’espansione di un contagio tipo COVID19 con PyGame e OpenGL

Ripropongo un esercizio in Python simile a quello svolto in JavaScript in Simulazione sull’espansione del contagio da Coronavirus (COVID-19)

Questa volta utilizzeremo PyGame e OpenGL per costruire la simulazione, similmente a quanto fatto nel precedente articolo. Il programma è stato svolto in Python 3.9.

import pygame as pg
from pygame.locals import *

from OpenGL.GL import *
from OpenGL.GLU import *

import math
from copy import copy
import random

import matplotlib.pyplot as plt

dati = [
    {"infetto":False,"velocita":10,"numero":200},
    {"infetto":False,"velocita":0,"numero":10},
    {"infetto":True,"velocita":10,"numero":1}
    ]

class Simulazione:

    def __init__(s, w = 1200, h = 800, dati = []):

        s.posizioni = []

        s.ratio = w / h
        s.w = w
        s.h = h

        pg.init()
        schermo = (w,h)
        pg.display.set_mode(schermo, DOUBLEBUF|OPENGL)

        # in movimento
        for d in dati:
            for i in range(d["numero"]):
                x = random.randint(-w/2+10,w/2-10)
                y = random.randint(-h/2+10,h/2-10)
                a = 2*math.pi*random.random()
                s.posizioni.append(Punto(x,y,d["velocita"],a,infetto=d["infetto"]))

        infezioni = []

        while True:
            for event in pg.event.get():
                if event.type == pg.QUIT:
                    pg.quit()
                    quit()
        
            glClearColor(1.0, 1.0, 1.0, 1.0)
            glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT)

            tot_infetti = 0

            for p in s.posizioni:
                p.muovi()
                s.disegnaPunto(p.x,p.y,raggio=p.raggio,colore=p.colore)
                if p.infetto and not p.guarito: tot_infetti += 1

            infezioni.append(tot_infetti)

            s.controllaUrti()

            pg.display.flip()
            pg.time.wait(10)

            if tot_infetti == 0:
                pg.quit()
                break

        plt.plot(range(len(infezioni)),infezioni)
        plt.title("curva contagi")
        plt.xlabel("periodo")
        plt.ylabel("contagi")
        plt.show()
        

    def controllaUrti(s):
        for p in s.posizioni:
            if copy(p) in s.posizioni:
                pass

    def disegnaPunto(s,x,y,lati=10,raggio=20,colore=(0.0, 0.0, 1.0)):
        raggio = 2 * raggio / s.w
        x = 2 * x / s.w
        y = 2 * y / s.h
        r,g,b = colore
        glColor3f(r,g,b)
        glBegin(GL_POLYGON)
        for v in range(lati):
            angolo = float(v) * 2.0 * math.pi / lati
            glVertex2f(math.cos(angolo)*raggio + x,math.sin(angolo)*raggio*s.ratio + y)
        glEnd()

class Punto:

    def __init__(s,x,y,v=3,alfa=0,colore=(0.0, 0.0, 1.0),raggio=5,infetto=False):
        s.x = x
        s.y = y
        s.v = v
        s.alfa = alfa
        s.id = id(s)
        s.colore = colore
        s.raggio = raggio
        s.urtato = False
        s.guarito = False
        s.infetto = infetto
        s.durata_infezione = 120 # cicli

    def __eq__(s,o):
        if math.sqrt((s.x - o.x)**2+(s.y - o.y)**2) < s.raggio * 2 and s.id != o.id:
            salfa = s.alfa
            oalfa = o.alfa
            if (s.infetto and not s.guarito) or (o.infetto and not o.guarito):
                s.infetto = o.infetto = True
            if not s.urtato: s.urto(oalfa)
            if not o.urtato: o.urto(salfa)
            return True
        else:
            return False

    def muovi(s):

        s.urtato = False

        if s.infetto: s.durata_infezione -= 1
        if s.durata_infezione < 0:
            s.guarito = True
            s.colore=(0.0, 1.0, 0.0)
        if s.infetto and not s.guarito: s.colore=(1.0, 0.0, 0.0)
        
        dx = s.v * math.cos(s.alfa)
        dy = s.v * math.sin(s.alfa)

        if s.x+dx >= 600 or s.x+dx <= -600:
            s.alfa = math.pi-s.alfa
            dx = s.v * math.cos(s.alfa)
            dy = s.v * math.sin(s.alfa)

        if s.y+dy >= 400 or s.y+dy <= -400:
            s.alfa = -s.alfa
            dx = s.v * math.cos(s.alfa)
            dy = s.v * math.sin(s.alfa)

        s.x += dx
        s.y += dy

        if s.x >= 600 or s.x <= -600 or s.y >= 400 or s.y <= -400:
            s.v = -s.v

    def urto(s,theta):
        s.alfa = s.alfa+theta
        s.urtato = True


Simulazione(dati=dati)

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

import pygame as pg

from pygame.locals import *

from OpenGL.GL import *

from OpenGL.GLU import *

import math

from copy import copy

import random

import matplotlib.pyplot as plt

dati = [

{"infetto":False,"velocita":10,"numero":200},

{"infetto":False,"velocita":0,"numero":10},

{"infetto":True,"velocita":10,"numero":1}

]

class Simulazione:

def __init__(s, w = 1200, h = 800, dati = []):

s.posizioni = []

s.ratio = w / h

s.w = w

s.h = h

pg.init()

schermo = (w,h)

pg.display.set_mode(schermo, DOUBLEBUF|OPENGL)

# in movimento

for d in dati:

for i in range(d["numero"]):

x = random.randint(-w/2+10,w/2-10)

y = random.randint(-h/2+10,h/2-10)

a = 2*math.pi*random.random()

s.posizioni.append(Punto(x,y,d["velocita"],a,infetto=d["infetto"]))

infezioni = []

while True:

for event in pg.event.get():

if event.type == pg.QUIT:

pg.quit()

quit()

glClearColor(1.0, 1.0, 1.0, 1.0)

glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT)

tot_infetti = 0

for p in s.posizioni:

p.muovi()

s.disegnaPunto(p.x,p.y,raggio=p.raggio,colore=p.colore)

if p.infetto and not p.guarito: tot_infetti += 1

infezioni.append(tot_infetti)

s.controllaUrti()

pg.display.flip()

pg.time.wait(10)

if tot_infetti == 0:

pg.quit()

break

plt.plot(range(len(infezioni)),infezioni)

plt.title("curva contagi")

plt.xlabel("periodo")

plt.ylabel("contagi")

plt.show()

def controllaUrti(s):

for p in s.posizioni:

if copy(p) in s.posizioni:

pass

def disegnaPunto(s,x,y,lati=10,raggio=20,colore=(0.0, 0.0, 1.0)):

raggio = 2 * raggio / s.w

x = 2 * x / s.w

y = 2 * y / s.h

r,g,b = colore

glColor3f(r,g,b)

glBegin(GL_POLYGON)

for v in range(lati):

angolo = float(v) * 2.0 * math.pi / lati

glVertex2f(math.cos(angolo)*raggio + x,math.sin(angolo)*raggio*s.ratio + y)

glEnd()

class Punto:

def __init__(s,x,y,v=3,alfa=0,colore=(0.0, 0.0, 1.0),raggio=5,infetto=False):

s.x = x

s.y = y

s.v = v

s.alfa = alfa

s.id = id(s)

s.colore = colore

s.raggio = raggio

s.urtato = False

s.guarito = False

s.infetto = infetto

s.durata_infezione = 120 # cicli

def __eq__(s,o):

if math.sqrt((s.x - o.x)**2+(s.y - o.y)**2) < s.raggio * 2 and s.id != o.id:

salfa = s.alfa

oalfa = o.alfa

if (s.infetto and not s.guarito) or (o.infetto and not o.guarito):

s.infetto = o.infetto = True

if not s.urtato: s.urto(oalfa)

if not o.urtato: o.urto(salfa)

return True

else:

return False

def muovi(s):

s.urtato = False

if s.infetto: s.durata_infezione -= 1

if s.durata_infezione < 0:

s.guarito = True

s.colore=(0.0, 1.0, 0.0)

if s.infetto and not s.guarito: s.colore=(1.0, 0.0, 0.0)

dx = s.v * math.cos(s.alfa)

dy = s.v * math.sin(s.alfa)

if s.x+dx >= 600 or s.x+dx <= -600:

s.alfa = math.pi-s.alfa

dx = s.v * math.cos(s.alfa)

dy = s.v * math.sin(s.alfa)

if s.y+dy >= 400 or s.y+dy <= -400:

s.alfa = -s.alfa

dx = s.v * math.cos(s.alfa)

dy = s.v * math.sin(s.alfa)

s.x += dx

s.y += dy

if s.x >= 600 or s.x <= -600 or s.y >= 400 or s.y <= -400:

s.v = -s.v

def urto(s,theta):

s.alfa = s.alfa+theta

s.urtato = True

Simulazione(dati=dati)

Il risultato produrrà qualcosa di simile a questo:

Vedi articolo

23 Aprile 2021 Nessun commento

[python] Calcolare la dimensione delle cartelle sul computer e trovare quelle più grandi

Ecco un veloce script in python per ricavare la dimensione delle cartelle sul computer (vale sia per Windows che Mac e Linux) e stampare l’elenco ordinato (dalla più grande alla più piccola) di tutte quelle trovate sopra una certa dimensione.

A me è stato molto utile per svuotare C: che si era riempito di cartelle temporanee, di cache e cose totalmente dimenticate.

import os
import math

class CalcolaDimensione:

    def __init__(s):
        s.cartelle = []

    def leggi_cartella(s,path):
        try:
            dim = 0
            for file in os.listdir(path):
                tmp = path + "\\" + file
                if os.path.isdir(tmp):
                    dim += s.leggi_cartella(tmp)
                else:
                    dim += os.path.getsize(tmp)
            s.cartelle.append({
                "path": path,
                "bytes": dim,
                "size": s.dimensione(dim)
                })
            return dim
        except:
            print("Errore: %s" % path)
            return 0

    def ordina(s):
        s.cartelle.sort(key=lambda e: e["bytes"],reverse=True)

    def dimensione(s,dim):
        if dim == 0: return "0B"
        nomi = ("B","KB","MB","GB","TB")
        i = int(math.floor(math.log(dim,1024)))
        p = math.pow(1024,i)
        s = round(dim / p,2)
        return "%s %s" % (s,nomi[i])

cd = CalcolaDimensione()
cd.leggi_cartella("C:\\")
cd.ordina()
for c in cd.cartelle:
    if c["bytes"] > 1024*1024*200:
        print(c["size"],c["path"])

import os

import math

class CalcolaDimensione:

def __init__(s):

s.cartelle = []

def leggi_cartella(s,path):

try:

dim = 0

for file in os.listdir(path):

tmp = path + "\\" + file

if os.path.isdir(tmp):

dim += s.leggi_cartella(tmp)

else:

dim += os.path.getsize(tmp)

s.cartelle.append({

"path": path,

"bytes": dim,

"size": s.dimensione(dim)

})

return dim

except:

print("Errore: %s" % path)

return 0

def ordina(s):

s.cartelle.sort(key=lambda e: e["bytes"],reverse=True)

def dimensione(s,dim):

if dim == 0: return "0B"

nomi = ("B","KB","MB","GB","TB")

i = int(math.floor(math.log(dim,1024)))

p = math.pow(1024,i)

s = round(dim / p,2)

return "%s %s" % (s,nomi[i])

cd = CalcolaDimensione()

cd.leggi_cartella("C:\\")

cd.ordina()

for c in cd.cartelle:

if c["bytes"] > 1024*1024*200:

print(c["size"],c["path"])

Lo script è stato scritto per Python 3.9

L’ouput finale genera qualcosa di simile (nel mio caso vedo che le macchine virtuali di Android occupano da sole 24GB!)

Faccio notare che nella stampa finale ho ridotto l’elenco a cartelle maggiori di 200MB.

Vedi articolo

26 Febbraio 2021 Nessun commento

[python] Semplice esercizio per riconoscere immagini di frutti con TensorFlow (machine learning)

Vogliamo realizzare un semplice programma in Python che sia in grado di riconoscere, utilizzando TensorFlow e machine learning, delle immagini di frutti.

Questo esercizio riprende i medesimi concetti già visti in: [python] Semplice esercizio su TensorFlow e il riconoscimento delle immagini nel gioco del Tris (Machine Learning)

Dato il seguente set di immagini (qui unite in una singola), vogliamo addestrare il programma a riuscire a riconoscere correttamente i frutti rappresentati:

Per farlo addestreremo il programma con altre immagini di training, suddivise rispettivamente in mele (che forse assomigliano più a dei pomodori), pere e banane:

Il risultato che vogliamo ottenere analizzando la prima immagine sarà qualcosa del genere (abbiamo tagliato l’immagine in tutte le sottoparti):

I tre numeri rappresentano la percentuale di probabilità per cui l’immagine sia, rispettivamente, una mela, una pera o una banana. Questo significa che la prima immagine è al 100% di probabilità una pera, mentre la seconda una banana ecc.

Il progetto si sviluppa in Python 3.7. Prima di procedere assicuriamoci di aver installato tutte le librerie necessarie, in particolare:

pip install Pillow
pip install numpy
pip install tensorflow
pip install matplotlib

pip install Pillow

pip install numpy

pip install tensorflow

pip install matplotlib

A questo punto prepariamo le immagini per il training ed il test. Attraverso le immagini di training alleneremo il nostro algoritmo, mentre useremo quelle per il test per verificare l’efficacia. Sottolineo ancora una volta come questo sia un esempio semplificato al massimo, utilizzando immagini semplici per non dover produrre una grande mole di dati sia per il training che per il test.

Per preparare le immagini dobbiamo tagliare i quattro file precedentemente preparati. A tale scopo creiamo una classe per elaborare le immagini nel modo seguente (nei commenti c’è la descrizione delle singole operazioni):

class ElaboraImmagini:

    # acquisiamo i dati per le immagini, con i seguenti argomenti
    # orig: lista che contiene il percorso alle immagini originali da tagliare
    # dest: cartella di destinazione nella quale salvare le immagini
    # n: numero di immagini in colonna
    # w: larghezza delle singole immagini
    def __init__(s, orig = [], dest = None, n = 4, w = 100):

        # prendiamo il percorso originale della cartella nella quale ci troviamo
        # ovvero dove si trova lo script di Python
        s.__orig_dir = os.path.dirname(os.path.realpath(__file__))
        # impostiamo la variabile privata con la lista delle immagini da elaborare
        s.__orig = orig
        # creiamo la cartella di destinazione
        s.__dest = s.__orig_dir + "\\" + dest

        # se la cartella non esiste...
        if not os.path.exists(s.__dest):
            # ... allora la creiamo
            os.makedirs(s.__dest)

        # salviamo n e w in variabili private
        s.__n = n
        s.__w = w

        # chiamiamo l'elaborazione delle immagini
        s.elabora()

    # creiamo il metodo per elaborare le immagini
    def elabora(s):

        # per ogni file nella lista di origine
        for f in s.__orig:
            # creiamo il nome del file con il percorso assoluto
            nome_file = s.__orig_dir + "\\" + f
            # per ogni riga...
            for i in range(s.__n):
                # ... e per ogni colonna
                for j in range(s.__n):
                    # ritagliamo le immagini con l'apposito metodo
                    # al metodo verranno passate le coordinate come 4-tupla
                    # calcolata da righe e colonne, oltre al nome del file da creare
                    # il nome lo creiamo come: nome del file senza estensione + conteggio
                    # quindi se stiamo tagliando banane.png avremo banane_x.png
                    # in questo modo potremo riconoscere le immagini dai nomi dei file
                    s.ritaglia( (j*s.__w,i*s.__w,(j+1)*s.__w,(i+1)*s.__w) , \
                                nome_file , \
                                os.path.basename(nome_file)[:-4] + "_" + str( i * s.__n + j) + ".png")

    # ritaglia con i seguenti argomenti:
    # coor: posizione left, top, right, bottom, come se fossero x e y insomma
    # nome_file: nome del file corrente
    # nome_dest: nome del file da creare
    def ritaglia(s, coor, nome_file, nome_dest):
        # apriamo il file
        img = Image.open(nome_file)
        # ritagliamolo
        cropped = img.crop(coor)
        # creiamo la posizione di salvataggio
        file_salvato = s.__dest + "\\" + nome_dest
        # salviamo
        cropped.save(file_salvato)

class ElaboraImmagini:

# acquisiamo i dati per le immagini, con i seguenti argomenti

# orig: lista che contiene il percorso alle immagini originali da tagliare

# dest: cartella di destinazione nella quale salvare le immagini

# n: numero di immagini in colonna

# w: larghezza delle singole immagini

def __init__(s, orig = [], dest = None, n = 4, w = 100):

# prendiamo il percorso originale della cartella nella quale ci troviamo

# ovvero dove si trova lo script di Python

s.__orig_dir = os.path.dirname(os.path.realpath(__file__))

# impostiamo la variabile privata con la lista delle immagini da elaborare

s.__orig = orig

# creiamo la cartella di destinazione

s.__dest = s.__orig_dir + "\\" + dest

# se la cartella non esiste...

if not os.path.exists(s.__dest):

# ... allora la creiamo

os.makedirs(s.__dest)

# salviamo n e w in variabili private

s.__n = n

s.__w = w

# chiamiamo l'elaborazione delle immagini

s.elabora()

# creiamo il metodo per elaborare le immagini

def elabora(s):

# per ogni file nella lista di origine

for f in s.__orig:

# creiamo il nome del file con il percorso assoluto

nome_file = s.__orig_dir + "\\" + f

# per ogni riga...

for i in range(s.__n):

# ... e per ogni colonna

for j in range(s.__n):

# ritagliamo le immagini con l'apposito metodo

# al metodo verranno passate le coordinate come 4-tupla

# calcolata da righe e colonne, oltre al nome del file da creare

# il nome lo creiamo come: nome del file senza estensione + conteggio

# quindi se stiamo tagliando banane.png avremo banane_x.png

# in questo modo potremo riconoscere le immagini dai nomi dei file

s.ritaglia( (j*s.__w,i*s.__w,(j+1)*s.__w,(i+1)*s.__w) , \

nome_file , \

os.path.basename(nome_file)[:-4] + "_" + str( i * s.__n + j) + ".png")

# ritaglia con i seguenti argomenti:

# coor: posizione left, top, right, bottom, come se fossero x e y insomma

# nome_file: nome del file corrente

# nome_dest: nome del file da creare

def ritaglia(s, coor, nome_file, nome_dest):

# apriamo il file

img = Image.open(nome_file)

# ritagliamolo

cropped = img.crop(coor)

# creiamo la posizione di salvataggio

file_salvato = s.__dest + "\\" + nome_dest

# salviamo

cropped.save(file_salvato)

Per elaborare i due gruppi di immagini ci sarà sufficiente chiamare:

ElaboraImmagini(["mele.png","pere.png","banane.png"],"TRAINING")
ElaboraImmagini(["frutta.png"],"TEST")

1 2	ElaboraImmagini(["mele.png","pere.png","banane.png"],"TRAINING") ElaboraImmagini(["frutta.png"],"TEST")

A questo punto creiamo una classe per elaborare questa base dati, nel modo seguente:

class CreaDBImmagini:

    # creiamo delle "costanti" giusto per codificare il tipo di output
    # che vogliamo ottenere passando il tipo al costruttore
    TEST = 0
    TRAINING = 1

    # qui codifichiamo la frutta
    MELE = 0
    PERE = 1
    BANANE = 2

    # passiamo al costruttore due argomenti:
    # path: il percorso da cui leggere le immagini
    # tipo: il tipo di elaborazione che vogliamo fare (TEST o TRAINING)
    def __init__(s, path, tipo = 0):
        s.__path = path
        # lista che conterrà le immagini in byte
        s.__immagini = []
        # lista contenente le descrizioni
        s.__descrizioni = []
        s.__tipo = tipo

        s.elabora()

    # elaboriamo la cartella con le immagini
    def elabora(s):
        # per ciascuna immagine nella cartella
        for f in os.listdir(s.__path):
            # creiamo il percorso del file
            percorso_file = s.__path + "\\" + f
            # se il file esiste (per come è costruito il metodo non c'è
            # motivo per cui il file non debba esistere, in realtà
            # verifichiamo che eventualmente non sia una cartella)
            if os.path.isfile(percorso_file):
                # leggiamo l'immagine usando la libreria Pillow
                img = Image.open(percorso_file)
                # trasformiamo i byte dell'immagine in un array di NumPy
                aimg = np.asarray(img)
                # aggiungiamo tale array alla lista delle immagini
                s.__immagini.append(aimg)

                # se elaboriamo le immagini per il training...
                if s.__tipo == s.TRAINING:
                    # preniamo il tipo del frutto dal nome
                    # ricordiamoci che i nomi sono del tipo mela_1.png
                    # quindi spezziamo il nome su _ e prendiamo la prima
                    # parte
                    frutto = f.split("_")[0]
                    # codifichiamo il nome con il numero
                    if frutto == "mele": desc = s.MELE
                    if frutto == "pere": desc = s.PERE
                    if frutto == "banane": desc = s.BANANE
                    # aggiungiamo tale numero alla lista delle descrizioni
                    s.__descrizioni.append(desc)

                # in caso di test ci accontentiamo dei meri nomi dei file
                if s.__tipo == s.TEST:
                    s.__descrizioni.append(f)

    # metodo per restituire la lista di immagini e descrizioni
    # codificate come array di NumPy
    def get(s):
        return (np.array(s.__immagini), np.array(s.__descrizioni))

class CreaDBImmagini:

# creiamo delle "costanti" giusto per codificare il tipo di output

# che vogliamo ottenere passando il tipo al costruttore

TEST = 0

TRAINING = 1

# qui codifichiamo la frutta

MELE = 0

PERE = 1

BANANE = 2

# passiamo al costruttore due argomenti:

# path: il percorso da cui leggere le immagini

# tipo: il tipo di elaborazione che vogliamo fare (TEST o TRAINING)

def __init__(s, path, tipo = 0):

s.__path = path

# lista che conterrà le immagini in byte

s.__immagini = []

# lista contenente le descrizioni

s.__descrizioni = []

s.__tipo = tipo

s.elabora()

# elaboriamo la cartella con le immagini

def elabora(s):

# per ciascuna immagine nella cartella

for f in os.listdir(s.__path):

# creiamo il percorso del file

percorso_file = s.__path + "\\" + f

# se il file esiste (per come è costruito il metodo non c'è

# motivo per cui il file non debba esistere, in realtà

# verifichiamo che eventualmente non sia una cartella)

if os.path.isfile(percorso_file):

# leggiamo l'immagine usando la libreria Pillow

img = Image.open(percorso_file)

# trasformiamo i byte dell'immagine in un array di NumPy

aimg = np.asarray(img)

# aggiungiamo tale array alla lista delle immagini

s.__immagini.append(aimg)

# se elaboriamo le immagini per il training...

if s.__tipo == s.TRAINING:

# preniamo il tipo del frutto dal nome

# ricordiamoci che i nomi sono del tipo mela_1.png

# quindi spezziamo il nome su _ e prendiamo la prima

# parte

frutto = f.split("_")[0]

# codifichiamo il nome con il numero

if frutto == "mele": desc = s.MELE

if frutto == "pere": desc = s.PERE

if frutto == "banane": desc = s.BANANE

# aggiungiamo tale numero alla lista delle descrizioni

s.__descrizioni.append(desc)

# in caso di test ci accontentiamo dei meri nomi dei file

if s.__tipo == s.TEST:

s.__descrizioni.append(f)

# metodo per restituire la lista di immagini e descrizioni

# codificate come array di NumPy

def get(s):

return (np.array(s.__immagini), np.array(s.__descrizioni))

Fatto tutto questo possiamo anzitutto costruire il nostro modello, che andremo a salvare, nella stessa cartella dell’eseguibile come modello_frutta.

Per creare il modello anzitutto preleviamo le immagini con:

train_img, train_desc = CreaDBImmagini("TRAINING",CreaDBImmagini.TRAINING).get()

1	train_img, train_desc = CreaDBImmagini("TRAINING",CreaDBImmagini.TRAINING).get()

Costruiamo poi il nostro modello:

modello = keras.Sequential([
            keras.layers.Flatten(input_shape=(100,100,3)),
            keras.layers.Dense(128, activation="relu"),
            keras.layers.Dense(3, activation="softmax")
        ])

modello = keras.Sequential([

keras.layers.Flatten(input_shape=(100,100,3)),

keras.layers.Dense(128, activation="relu"),

keras.layers.Dense(3, activation="softmax")

])

I tre layer servono rispettivamente per:

keras.layers.Flatten(input_shape=(100,100,3)) ci permette di ridurre ad una dimensione la matrice tridimensionale delle immagini (100 righe x 100 colonne x 3 byte di colore) contenente 30.000 byte. Per farlo dobbiamo ricordarci lo shape dei dati passati in input, che provengono da una lista, contenente a sua volte una lista tridimensionale.
keras.layers.Dense(128, activation="relu") applica l’algoritmo relu ai dati ottenuti dal primo layer, su 128 nodi (il numero è arbitrario, scelto per via principalmente sperimentale)
keras.layers.Dense(3, activation="softmax") applichiamo l’algoritmo softmax per ridurre tutte le informazioni a 3 nodi, rappresentati i 3 dati di output che vogliamo ottenere.

Aggiungo una nota per comprendere meglio il passaggio dei layer intermedi. Il primo layer è necessario per ridurre i dati in input ad una forma univoca, mentre l’ultimo layer serve a portare in output i dati che passiamo come “descrizione”, ovvero output conosciuto, durante il training. I layer intermedi invece possono essere molteplici, e servono per manipolare i diversi aspetti dell’informazione, tentando di ridurla ad una schematizzazione ricorrente. Per capire meglio questo processo immaginiamo di voler interpretare un’immagine (non succede la medesima cosa, ma l’esempio descrive bene il concetto generale).

Se avessimo un immagine come questa di seguito, avremmo a che fare con un’enorme quantità di dettagli diversi da analizzare. Essendo l’immagine grande 1200 x 761 pixel, potremmo dire di aver bisogno di 1200×761 = 913.200 nodi per interpretare ogni informazione singolarmente, quindi potremmo decidere di utilizzare un layer con 913.200 nodi (o neuroni). Questo vorrebbe dire che diamo importanza ad OGNI singolo nodo e quindi ad OGNI singolo dettaglio dell’informazione. Laddove volessimo confrontare immagini diverse sarebbe molto complesso cercare di trovare un’affinità tra i singoli nodi e quindi un percorso che riconduca al medesimo output desiderato.

Albania Sud | Vagabondo

Dello stesso posto potremmo avere ad esempio la seguente immagine:

Turismo dentale Albania | EliteDental

Le due immagini risulterebbero, per il computer, prese tali e quali, fondamentalmente diverse. Adesso proviamo a ridurre il dettaglio dei pixel, nel modo seguente:

Adesso possiamo identificare, nelle immagini divese, zone analoghe associabili per forma e colore tra di loro (nonostante le differenze ancora esistenti). In questo caso abbiamo ridotto le immagini in quadrati da 36×36 pixel ciascuno, quindi in totale abbiamo ridotto il tutto a circa 700 nodi. Ovviamente si è ridotta la complessità e di conseguenza il livello di dettaglio. Potremo apprezzare meno dettagli, ma confrontare meglio i macro-elementi presenti in entrambe le immagini.

Detto tutto questo compiliamo il nostro modello:

modello.compile(optimizer="adam",
            loss="sparse_categorical_crossentropy",
            metrics=["accuracy"])

modello.compile(optimizer="adam",

loss="sparse_categorical_crossentropy",

metrics=["accuracy"])

E infine compiliamolo e salviamolo:

modello.fit(train_img, train_desc, epochs=20)
modello.save("modello_frutta")

1 2	modello.fit(train_img, train_desc, epochs=20) modello.save("modello_frutta")

Per usare il modello salvato lo possiamo caricare usando:

modello = keras.models.load_model("modello_frutta")

1	modello = keras.models.load_model("modello_frutta")

A questo punto carichiamo le immagini di TEST e mettiamo a prova il nostro modello:

test_img, test_desc = CreaDBImmagini("TEST",CreaDBImmagini.TEST).get()

1	test_img, test_desc = CreaDBImmagini("TEST",CreaDBImmagini.TEST).get()

Adesso facciamo prevedere al modello i risultati:

previsione = modello.predict(test_img)

1	previsione = modello.predict(test_img)

Infine stampiamoli a video per ottenere il risultato iniziale:

for i, img in enumerate(test_img):
    previsione = modello.predict(np.array([img]))
    print(previsione, test_desc[i])

for i, img in enumerate(test_img):

previsione = modello.predict(np.array([img]))

print(previsione, test_desc[i])

Riporto anche tutto il codice insieme:

from __future__ import absolute_import, division, print_function, unicode_literals
 
from PIL import Image
import numpy as np
import os
 
import tensorflow as tf
from tensorflow import keras
import matplotlib.pyplot as plt


class ElaboraImmagini:

    # acquisiamo i dati per le immagini, con i seguenti argomenti
    # orig: lista che contiene il percorso alle immagini originali da tagliare
    # dest: cartella di destinazione nella quale salvare le immagini
    # n: numero di immagini in colonna
    # w: larghezza delle singole immagini
    def __init__(s, orig = [], dest = None, n = 4, w = 100):

        # prendiamo il percorso originale della cartella nella quale ci troviamo
        # ovvero dove si trova lo script di Python
        s.__orig_dir = os.path.dirname(os.path.realpath(__file__))
        # impostiamo la variabile privata con la lista delle immagini da elaborare
        s.__orig = orig
        # creiamo la cartella di destinazione
        s.__dest = s.__orig_dir + "\\" + dest

        # se la cartella non esiste...
        if not os.path.exists(s.__dest):
            # ... allora la creiamo
            os.makedirs(s.__dest)

        # salviamo n e w in variabili private
        s.__n = n
        s.__w = w

        # chiamiamo l'elaborazione delle immagini
        s.elabora()

    # creiamo il metodo per elaborare le immagini
    def elabora(s):

        # per ogni file nella lista di origine
        for f in s.__orig:
            # creiamo il nome del file con il percorso assoluto
            nome_file = s.__orig_dir + "\\" + f
            # per ogni riga...
            for i in range(s.__n):
                # ... e per ogni colonna
                for j in range(s.__n):
                    # ritagliamo le immagini con l'apposito metodo
                    # al metodo verranno passate le coordinate come 4-tupla
                    # calcolata da righe e colonne, oltre al nome del file da creare
                    # il nome lo creiamo come: nome del file senza estensione + conteggio
                    # quindi se stiamo tagliando banane.png avremo banane_x.png
                    # in questo modo potremo riconoscere le immagini dai nomi dei file
                    s.ritaglia( (j*s.__w,i*s.__w,(j+1)*s.__w,(i+1)*s.__w) , \
                                nome_file , \
                                os.path.basename(nome_file)[:-4] + "_" + str( i * s.__n + j) + ".png")

    # ritaglia con i seguenti argomenti:
    # coor: posizione left, top, right, bottom, come se fossero x e y insomma
    # nome_file: nome del file corrente
    # nome_dest: nome del file da creare
    def ritaglia(s, coor, nome_file, nome_dest):
        # apriamo il file
        img = Image.open(nome_file)
        # ritagliamolo
        cropped = img.crop(coor)
        # creiamo la posizione di salvataggio
        file_salvato = s.__dest + "\\" + nome_dest
        # salviamo
        cropped.save(file_salvato)



ElaboraImmagini(["mele.png","pere.png","banane.png"],"TRAINING")
ElaboraImmagini(["frutta.png"],"TEST")

class CreaDBImmagini:

    # creiamo delle "costanti" giusto per codificare il tipo di output
    # che vogliamo ottenere passando il tipo al costruttore
    TEST = 0
    TRAINING = 1

    # qui codifichiamo la frutta
    MELE = 0
    PERE = 1
    BANANE = 2

    # passiamo al costruttore due argomenti:
    # path: il percorso da cui leggere le immagini
    # tipo: il tipo di elaborazione che vogliamo fare (TEST o TRAINING)
    def __init__(s, path, tipo = 0):
        s.__path = path
        # lista che conterrà le immagini in byte
        s.__immagini = []
        # lista contenente le descrizioni
        s.__descrizioni = []
        s.__tipo = tipo

        s.elabora()

    # elaboriamo la cartella con le immagini
    def elabora(s):
        # per ciascuna immagine nella cartella
        for f in os.listdir(s.__path):
            # creiamo il percorso del file
            percorso_file = s.__path + "\\" + f
            # se il file esiste (per come è costruito il metodo non c'è
            # motivo per cui il file non debba esistere, in realtà
            # verifichiamo che eventualmente non sia una cartella)
            if os.path.isfile(percorso_file):
                # leggiamo l'immagine usando la libreria Pillow
                img = Image.open(percorso_file)
                # trasformiamo i byte dell'immagine in un array di NumPy
                aimg = np.asarray(img)
                # aggiungiamo tale array alla lista delle immagini
                s.__immagini.append(aimg)

                # se elaboriamo le immagini per il training...
                if s.__tipo == s.TRAINING:
                    # preniamo il tipo del frutto dal nome
                    # ricordiamoci che i nomi sono del tipo mela_1.png
                    # quindi spezziamo il nome su _ e prendiamo la prima
                    # parte
                    frutto = f.split("_")[0]
                    # codifichiamo il nome con il numero
                    if frutto == "mele": desc = s.MELE
                    if frutto == "pere": desc = s.PERE
                    if frutto == "banane": desc = s.BANANE
                    # aggiungiamo tale numero alla lista delle descrizioni
                    s.__descrizioni.append(desc)

                # in caso di test ci accontentiamo dei meri nomi dei file
                if s.__tipo == s.TEST:
                    s.__descrizioni.append(f)

    # metodo per restituire la lista di immagini e descrizioni
    # codificate come array di NumPy
    def get(s):
        return (np.array(s.__immagini), np.array(s.__descrizioni))

# qui alleno il modello (ora disattivato con False)
if True:
    train_img, train_desc = CreaDBImmagini("TRAINING",CreaDBImmagini.TRAINING).get()

    modello = keras.Sequential([
            keras.layers.Flatten(input_shape=(100,100,3)),
            keras.layers.Dense(128, activation="relu"),
            keras.layers.Dense(3, activation="softmax")
        ])

    modello.compile(optimizer="adam",
            loss="sparse_categorical_crossentropy",
            metrics=["accuracy"])

    modello.fit(train_img, train_desc, epochs=20)

    modello.save("modello_frutta")

# qui uso il modello
if True:
    modello = keras.models.load_model("modello_frutta")

    test_img, test_desc = CreaDBImmagini("TEST",CreaDBImmagini.TEST).get()

    print("elenco di previsioni grezzo")
    previsione = modello.predict(test_img)

    print("elenco previsioni gestito")
    for i, img in enumerate(test_img):
        previsione = modello.predict(np.array([img]))
        print(previsione, test_desc[i])

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

from __future__ import absolute_import, division, print_function, unicode_literals

from PIL import Image

import numpy as np

import os

import tensorflow as tf

from tensorflow import keras

import matplotlib.pyplot as plt

class ElaboraImmagini:

# acquisiamo i dati per le immagini, con i seguenti argomenti

# orig: lista che contiene il percorso alle immagini originali da tagliare

# dest: cartella di destinazione nella quale salvare le immagini

# n: numero di immagini in colonna

# w: larghezza delle singole immagini

def __init__(s, orig = [], dest = None, n = 4, w = 100):

# prendiamo il percorso originale della cartella nella quale ci troviamo

# ovvero dove si trova lo script di Python

s.__orig_dir = os.path.dirname(os.path.realpath(__file__))

# impostiamo la variabile privata con la lista delle immagini da elaborare

s.__orig = orig

# creiamo la cartella di destinazione

s.__dest = s.__orig_dir + "\\" + dest

# se la cartella non esiste...

if not os.path.exists(s.__dest):

# ... allora la creiamo

os.makedirs(s.__dest)

# salviamo n e w in variabili private

s.__n = n

s.__w = w

# chiamiamo l'elaborazione delle immagini

s.elabora()

# creiamo il metodo per elaborare le immagini

def elabora(s):

# per ogni file nella lista di origine

for f in s.__orig:

# creiamo il nome del file con il percorso assoluto

nome_file = s.__orig_dir + "\\" + f

# per ogni riga...

for i in range(s.__n):

# ... e per ogni colonna

for j in range(s.__n):

# ritagliamo le immagini con l'apposito metodo

# al metodo verranno passate le coordinate come 4-tupla

# calcolata da righe e colonne, oltre al nome del file da creare

# il nome lo creiamo come: nome del file senza estensione + conteggio

# quindi se stiamo tagliando banane.png avremo banane_x.png

# in questo modo potremo riconoscere le immagini dai nomi dei file

s.ritaglia( (j*s.__w,i*s.__w,(j+1)*s.__w,(i+1)*s.__w) , \

nome_file , \

os.path.basename(nome_file)[:-4] + "_" + str( i * s.__n + j) + ".png")

# ritaglia con i seguenti argomenti:

# coor: posizione left, top, right, bottom, come se fossero x e y insomma

# nome_file: nome del file corrente

# nome_dest: nome del file da creare

def ritaglia(s, coor, nome_file, nome_dest):

# apriamo il file

img = Image.open(nome_file)

# ritagliamolo

cropped = img.crop(coor)

# creiamo la posizione di salvataggio

file_salvato = s.__dest + "\\" + nome_dest

# salviamo

cropped.save(file_salvato)

ElaboraImmagini(["mele.png","pere.png","banane.png"],"TRAINING")

ElaboraImmagini(["frutta.png"],"TEST")

class CreaDBImmagini:

# creiamo delle "costanti" giusto per codificare il tipo di output

# che vogliamo ottenere passando il tipo al costruttore

TEST = 0

TRAINING = 1

# qui codifichiamo la frutta

MELE = 0

PERE = 1

BANANE = 2

# passiamo al costruttore due argomenti:

# path: il percorso da cui leggere le immagini

# tipo: il tipo di elaborazione che vogliamo fare (TEST o TRAINING)

def __init__(s, path, tipo = 0):

s.__path = path

# lista che conterrà le immagini in byte

s.__immagini = []

# lista contenente le descrizioni

s.__descrizioni = []

s.__tipo = tipo

s.elabora()

# elaboriamo la cartella con le immagini

def elabora(s):

# per ciascuna immagine nella cartella

for f in os.listdir(s.__path):

# creiamo il percorso del file

percorso_file = s.__path + "\\" + f

# se il file esiste (per come è costruito il metodo non c'è

# motivo per cui il file non debba esistere, in realtà

# verifichiamo che eventualmente non sia una cartella)

if os.path.isfile(percorso_file):

# leggiamo l'immagine usando la libreria Pillow

img = Image.open(percorso_file)

# trasformiamo i byte dell'immagine in un array di NumPy

aimg = np.asarray(img)

# aggiungiamo tale array alla lista delle immagini

s.__immagini.append(aimg)

# se elaboriamo le immagini per il training...

if s.__tipo == s.TRAINING:

# preniamo il tipo del frutto dal nome

# ricordiamoci che i nomi sono del tipo mela_1.png

# quindi spezziamo il nome su _ e prendiamo la prima

# parte

frutto = f.split("_")[0]

# codifichiamo il nome con il numero

if frutto == "mele": desc = s.MELE

if frutto == "pere": desc = s.PERE

if frutto == "banane": desc = s.BANANE

# aggiungiamo tale numero alla lista delle descrizioni

s.__descrizioni.append(desc)

# in caso di test ci accontentiamo dei meri nomi dei file

if s.__tipo == s.TEST:

s.__descrizioni.append(f)

# metodo per restituire la lista di immagini e descrizioni

# codificate come array di NumPy

def get(s):

return (np.array(s.__immagini), np.array(s.__descrizioni))

# qui alleno il modello (ora disattivato con False)

if True:

train_img, train_desc = CreaDBImmagini("TRAINING",CreaDBImmagini.TRAINING).get()

modello = keras.Sequential([

keras.layers.Flatten(input_shape=(100,100,3)),

keras.layers.Dense(128, activation="relu"),

keras.layers.Dense(3, activation="softmax")

])

modello.compile(optimizer="adam",

loss="sparse_categorical_crossentropy",

metrics=["accuracy"])

modello.fit(train_img, train_desc, epochs=20)

modello.save("modello_frutta")

# qui uso il modello

if True:

modello = keras.models.load_model("modello_frutta")

test_img, test_desc = CreaDBImmagini("TEST",CreaDBImmagini.TEST).get()

print("elenco di previsioni grezzo")

previsione = modello.predict(test_img)

print("elenco previsioni gestito")

for i, img in enumerate(test_img):

previsione = modello.predict(np.array([img]))

print(previsione, test_desc[i])

Qui il progetto con le immagini scaricabile in formato zip.

Vedi articolo

25 Gennaio 2021 Nessun commento

[python] Semplice esercizio per creare il gioco del campo minato in Python (da console)

In questo semplice esercizio vogliamo riprodurre in Python, in modo un po’ rudimentale, quello che era il gioco del campo minato (poi campo fiorito) per Windows.

Quello che vogliamo ottenere assomiglierà a questo all’avvio:

Mentre alla vittoria otterremo qualcosa di simile:

Il gioco sarà costruito su una griglia 10×10, di 100 caselle in totale, che faremo selezionare all’utente con un numero da 1 a 100.

Anzitutto costruiamo la griglia fatta di oggetti di tipo Casella, definiti nel modo seguente:

class Casella:

    def __init__(s, mina = False):
        s.mina = mina
        s.aperta = False
        s.conteggio = 0

class Casella:

def __init__(s, mina = False):

s.mina = mina

s.aperta = False

s.conteggio = 0

Per costruire il campo useremo la funzione random.randint() per distribuire le mine in modo casuale, nel modo seguente:

campo = [[Casella(True if random.randint(0,difficolta)==0 else False) for j in range(n)] for i in range(n)]

1	campo = [[Casella(True if random.randint(0,difficolta)==0 else False) for j in range(n)] for i in range(n)]

In questo caso la variabile difficolta viene usata per bilanciare la distribuzione casuale. Se impostiamo difficolta su 2, avremo in media il 50% di caselle con mine (1/2). Se impostiamo difficolta su 10 allora avremo circa il 10% di mine (1/10), ecc.

Fatto questo dobbiamo costruire due metodi che si occuperanno rispettivamente di conteggiare le mine e aprire le celle. All’interno di entrambi i metodi useremo due cicli for ricordandoci che rispetto alla posizione attuale quelle intorno partiranno da [-1,-1] fino a [1,1]

Riporto di seguito il codice, commentato, dell’intero giochino realizzato a partire da queste idee:

import random

class Casella:

    def __init__(s, mina = False):
        s.mina = mina
        s.aperta = False
        s.conteggio = 0

def conteggio(i,j):

    global n,campo

    # se nella cella non c'è una mina allora procedi
    if campo[i][j].mina == False:
        # controlliamo le celle tutto intorno
        for di in range(-1,2):
            for dj in range(-1,2):
                # se la posizione è compresa nell'intervallo della matrice
                if (i+di > -1 and j+dj > -1) and (i+di < n and j+dj < n):
                    # se la cella è una mina
                    if campo[i+di][j+dj].mina == True:
                        # incrementiamo il contatore
                        campo[i][j].conteggio += 1
        # sfruttiamo il contatore per conteggiare il numero di mine nel gioco
        # se non abbiamo una mina restituiamo 0
        return 0
    else:
        #se abbiamo invece una mina restituiamo 1
        return 1

def controlla(i,j):

    global n,campo

    # se la cella è aperta non facciamo altro
    #restituiamo True per dire che il gioco continua
    if campo[i][j].aperta: return True

    # impostiamo la cella come aperta
    campo[i][j].aperta = True

    # se non abbiamo una mina e il conteggio è a 0, allora procediamo
    # questo perché, cliccando su una cella, vogliamo aprire tutte le celle vuote
    #che non hanno alcuna mina accanto
    if campo[i][j].mina == False and campo[i][j].conteggio == 0:
        for di in range(-1,2):
            for dj in range(-1,2):
                if (i+di > -1 and j+dj > -1) and (i+di < n and j+dj < n):
                    # se non abbiamo una mina e non siamo sulle celle diagonali
                    # l'apertura avviene solo in orizzontale e verticale
                    if not campo[i+di][j+dj].mina:
                        controlla(i+di,j+dj)
    # altrimenti se abbiamo una mina, restituiamo False
    elif campo[i][j].mina:
        return False
    # in tutti gli altri casi True
    return True

# difficoltà come probabilità di trovare mine, 1 / difficolta
difficolta = 10

while True:

    # stampiamo il menu
    print("-- MENU --")
    print("1. gioca")
    print("2. imposta difficoltà")
    print("0. esci")
    s = int(input("> "))

    # usciamo dal gioco
    if s == 0: break

    # giochiamo
    if s == 1:

        #dimensione del campo
        n = 10
        # disegniamo il campo
        campo = [[Casella(True if random.randint(0,difficolta)==0 else False) for j in range(n)] for i in range(n)]
        # true = continua il gioco, false = si ferma
        risultato = True
        totale_mine = 0

        # conteggiamo le mine rispetto alle caselle e le mine totali
        for i in range(n):
            for j in range(n):
                totale_mine += conteggio(i,j)

        # comincia l'inserimento
        while True:

            # numeri in cima
            print(end=" "*3)
            for i in range(n): print(i+1,end=" ")
            print()

            # conteggio chiuse
            ancora_chiuse = 0
            for nr, r in enumerate(campo):
                # numeri accanto
                print(nr,end=" "*2)
                for c in r:
                    # stampa a video
                    if c.aperta:
                        if c.mina: print("X",end=" ")
                        elif c.conteggio > 0: print(c.conteggio,end=" ")
                        else: print(" ",end=" ")
                    else:
                        if c.mina and not risultato: print("X",end=" ")
                        else:
                            print("-",end=" ")
                            ancora_chiuse += 1
                print()
                
            if not risultato:
                print("hai perso")
                break

            if ancora_chiuse <= totale_mine:
                print("hai vinto!")
                break

            # leggiamo l'input e trasformiamolo nella posizione i,j
            pos = int(input("posizione [1-%d]: " % (n**2)))
            i = int((pos-1)/n)
            j = pos - i*n - 1

            # controlliamo la cella corrente
            risultato = controlla(i,j)

    if s == 2:

        # impostiamo la difficoltà
        d = int(input("seleziona difficoltà (1 = facile, 2 = medio, 3 = difficile): "))
        if d == 1: difficolta = 10
        if d == 2: difficolta = 6
        if d == 3: difficolta = 4

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

import random

class Casella:

def __init__(s, mina = False):

s.mina = mina

s.aperta = False

s.conteggio = 0

def conteggio(i,j):

global n,campo

# se nella cella non c'è una mina allora procedi

if campo[i][j].mina == False:

# controlliamo le celle tutto intorno

for di in range(-1,2):

for dj in range(-1,2):

# se la posizione è compresa nell'intervallo della matrice

if (i+di > -1 and j+dj > -1) and (i+di < n and j+dj < n):

# se la cella è una mina

if campo[i+di][j+dj].mina == True:

# incrementiamo il contatore

campo[i][j].conteggio += 1

# sfruttiamo il contatore per conteggiare il numero di mine nel gioco

# se non abbiamo una mina restituiamo 0

return 0

else:

#se abbiamo invece una mina restituiamo 1

return 1

def controlla(i,j):

global n,campo

# se la cella è aperta non facciamo altro

#restituiamo True per dire che il gioco continua

if campo[i][j].aperta: return True

# impostiamo la cella come aperta

campo[i][j].aperta = True

# se non abbiamo una mina e il conteggio è a 0, allora procediamo

# questo perché, cliccando su una cella, vogliamo aprire tutte le celle vuote

#che non hanno alcuna mina accanto

if campo[i][j].mina == False and campo[i][j].conteggio == 0:

for di in range(-1,2):

for dj in range(-1,2):

if (i+di > -1 and j+dj > -1) and (i+di < n and j+dj < n):

# se non abbiamo una mina e non siamo sulle celle diagonali

# l'apertura avviene solo in orizzontale e verticale

if not campo[i+di][j+dj].mina:

controlla(i+di,j+dj)

# altrimenti se abbiamo una mina, restituiamo False

elif campo[i][j].mina:

return False

# in tutti gli altri casi True

return True

# difficoltà come probabilità di trovare mine, 1 / difficolta

difficolta = 10

while True:

# stampiamo il menu

print("-- MENU --")

print("1. gioca")

print("2. imposta difficoltà")

print("0. esci")

s = int(input("> "))

# usciamo dal gioco

if s == 0: break

# giochiamo

if s == 1:

#dimensione del campo

n = 10

# disegniamo il campo

campo = [[Casella(True if random.randint(0,difficolta)==0 else False) for j in range(n)] for i in range(n)]

# true = continua il gioco, false = si ferma

risultato = True

totale_mine = 0

# conteggiamo le mine rispetto alle caselle e le mine totali

for i in range(n):

for j in range(n):

totale_mine += conteggio(i,j)

# comincia l'inserimento

while True:

# numeri in cima

print(end=" "*3)

for i in range(n): print(i+1,end=" ")

print()

# conteggio chiuse

ancora_chiuse = 0

for nr, r in enumerate(campo):

# numeri accanto

print(nr,end=" "*2)

for c in r:

# stampa a video

if c.aperta:

if c.mina: print("X",end=" ")

elif c.conteggio > 0: print(c.conteggio,end=" ")

else: print(" ",end=" ")

else:

if c.mina and not risultato: print("X",end=" ")

else:

print("-",end=" ")

ancora_chiuse += 1

print()

if not risultato:

print("hai perso")

break

if ancora_chiuse <= totale_mine:

print("hai vinto!")

break

# leggiamo l'input e trasformiamolo nella posizione i,j

pos = int(input("posizione [1-%d]: " % (n**2)))

i = int((pos-1)/n)

j = pos - i*n - 1

# controlliamo la cella corrente

risultato = controlla(i,j)

if s == 2:

# impostiamo la difficoltà

d = int(input("seleziona difficoltà (1 = facile, 2 = medio, 3 = difficile): "))

if d == 1: difficolta = 10

if d == 2: difficolta = 6

if d == 3: difficolta = 4

Vedi articolo

29 Luglio 2020 1 commento

[python] Semplice esercizio su TensorFlow e il riconoscimento delle immagini nel gioco del Tris (Machine Learning)

Vogliamo realizzare un semplice programma in Python che sfrutti il riconoscimento delle immagini mediante TensorFlow e machine learning.

Il programma consentirà all’utente di pescare il risultato di una partita a Tris, da una cartella di immagini come la seguente:

Selezionando una partita il programma ci dirà chi ritiene che sia il vincitore e mostrerà lo schema della partita che ha dedotto a partire dall’immagine che gli abbiamo passato, nella maniera seguente:

1. Configurazione iniziale e librerie utilizzate

Per affrontare l’esercizio in questione abbiamo bisogno di alcune librerie. Il progetto verrà sviluppato in Python 3.7.

Possiamo installare le opportune librerie utilizzando PIP, nel caso specifico avremo bisogno delle seguenti installazioni:

pip install Pillow
pip install numpy
pip install tensorflow
pip install matplotlib

pip install Pillow

pip install numpy

pip install tensorflow

pip install matplotlib

Creiamo un file elaboratore.py nel quale svilupperemo l’intero programma. All’inizio inseriamo le seguenti istruzioni di importazione:

from __future__ import absolute_import, division, print_function, unicode_literals

from PIL import Image
import numpy as np
import os

import tensorflow as tf
from tensorflow import keras
import matplotlib.pyplot as plt

from __future__ import absolute_import, division, print_function, unicode_literals

from PIL import Image

import numpy as np

import os

import tensorflow as tf

from tensorflow import keras

import matplotlib.pyplot as plt

Faccio notare che la prima istruzione from __future__ import absolute_import, division, print_function, unicode_literals deve trovarsi all’inizio e non è una vera e propria importazione. Si tratta di una configurazione sul funzionamento di Python, che importa “funzionalità future” dal modulo fittizio __future__. E’ un modo per rendere disponibili, nella versione attuale, funzionalità previste in versioni successive, ma che ancora non sono state ufficialmente implementate.

Nel nostro caso specifico questa importazione non è essenziale (stiamo già lavorando in Python 3.7 e la funzione print non è più uno statement, bensì una funzione appunto, ecc), ma la possiamo lasciare per rendere compatibile il programma anche con versioni precedenti.

Detto questo procediamo allo sviluppo del necessario.

2. Dati iniziali

Per sviluppare il gioco utilizzeremo i seguenti set di dati (qui l’allegato da cui scaricarli):

Set delle immagini per l’addestramento del modello, ricaveremo le immagini da un’unica grande immagine originale chiamata training.jpg (questa è un’immagine contenente 144 disegni, metà sono O e l’altra metà sono X, disegnate a mano sul computer, ciascun elemento è grande 100×100 px, per un totale di 1200×1200 px, ovvero 12 righe x 12 colonne)
Piccolo set di immagini di test nel file test.jpg (solita dimensione 100×100 px per ciascuna immagine, per un totale di 4×4 = 16 elementi)
Archivio con 10 partite giocate a Tris di cui conosciamo il risultato e vogliamo farlo riconoscere al computer

3. Struttura del programma

Vogliamo creare 3 classi che si occuperanno di diversi aspetti del programma:

ElaboraImmagini – con questa classe elaboreremo le immagini di test, di addestramento e delle singole partite. In tutti e tre i casi si tratta di suddividere un’immagine originale in immagini più piccole; nei primi due casi, quello di test e addestramento, salveremo le immagini in una cartella da cui leggerle successivamente, mentre nel terzo caso, quello delle immagini che compongono una partita, salveremo il risultato in un vettore
CreaDBImmagini – con questa classe vogliamo elaborare le immagini di test e di addestramento salvate nelle rispettive cartelle, ottenendo dei vettori contenenti le immagini medesime e un elenco di output (o etichette) associati a ciascuna immagine
GiocoTris – la vera e propria classe che si occuperà dello sviluppo del gioco, preparando il modello di apprendimento, salvandolo e valutando il punteggio su ciascuna partita che verrà passata dal giocatore

Infine metteremo tutto in un semplice ciclo while che permetterà all’utente di scegliere un’immagine dall’elenco di quelle disponibili e farla analizzare.

4. Elaboriamo le immagini di addestramento e test

Creiamo una classe nella maniera seguente (nel codice ho inserito il commento sui singoli passaggi):

class ElaboraImmagini:

    # al costruttore della classe passiamo i seguenti argomenti:
    # orig: file dell'immagine originale da elaborare, per esempio training.jpg oppure gioco_0.jpg
    # dest: cartella di destinazione nella quale salvare le immagini ritagliate dall'immagine originale
    # n: dimensione del lato del quadrato dell'immagine, 12 per training.jpg, oppure 3 per l'immagine di gioco_0.jpg, praticamente il numero di colonne della griglia
    # w: dimensione di ciascuna cella della griglia in px, ogni immagine estratta avra' tale dimensione, per esempio 100 per immagini di 100x100px
    # returnList: se vogliamo che il risultato, ovvero le immagini ritagliate, anziche' essere salvato in una cartella, venga restituito in una lista
    def __init__(s, orig, dest = None, n = 12, w = 100, returnList = False):
        # impostiamo alcune proprieta' private della classe
        s.__return = returnList
        s.__lista = [] # questo sara' l'eventuale elenco delle immagini
        # preleviamo il percorso assoluto sul quale si trova l'immagine di origine
        s.__orig = os.path.abspath(orig)
        # se non vogliamo una lista, creiamo il percorso di salvataggio delle immagini
        #a tale scopo prendiamo la cartella dell'immagine sorgente e ad essa accodiamo la cartella di destinazione
        if not s.__return: s.__dest = os.path.dirname(s.__orig) + "\\" + dest

        # se non vogliamo una lista
        if not s.__return:
            # allora dovremo salvare le immagini in una cartella
            # se la cartella di destinazione non esiste
            if not os.path.exists(s.__dest):
                # allora la creiamo
                os.makedirs(s.__dest)

        # salviamo i valori in prorieta' private
        s.__n = n
        s.__w = w

        # elaboriamo le immagini
        s.elabora()

    # per elaborare le immagini dobbiamo ritagliarle da quella originale
    # creiamo dunque un metodo per ritagliare le immagini, passando per argomento le coordinate (coor) di ritaglio
    # per coordinate si intendono xi, yi e xf, yf di ciascun quadrato di ritaglio (vedere l'articolo per maggiori informazioni)
    def ritaglia(s, coor, i):
        # leggiamo l'immagine con PIL
        img = Image.open(s.__orig)
        # ritagliamo l'immagine secondo le coordinate passate
        cropped = img.crop(coor)
        # se non vogliamo una lista, allora salviamo l'immagine nella destinazione prescelta
        if not s.__return: cropped.save(s.__dest + "\\img_" + str(i) + ".jpg")
        # altrimenti restituiamo l'immagine come array di NumPy
        else: return np.asarray(cropped)

    # con questo metodo elaboriamo l'immagine, chiamando ritaglia() per ciascuna cella della griglia
    def elabora(s):
        # per ciascuna riga
        for i in range(s.__n):
            #per ciascuna colonna
            for j in range(s.__n):
                # esegui ritaglia passando le coordinate calcolate e il numero progressivo dell'immagine
                img = s.ritaglia( ( j*s.__w , i*s.__w , (j+1) *s.__w , (i+1) * s.__w ) , i * s.__n + j )
                # aggiungi l'immagine alla lista delle immagini che si potranno eventualmente restituire
                s.__lista.append(img)

    # preleviamo la lista delle immagini elaborate
    def get(s):
        # convertiamo la lista in un array di NumPy
        return np.array(s.__lista)

class ElaboraImmagini:

# al costruttore della classe passiamo i seguenti argomenti:

# orig: file dell'immagine originale da elaborare, per esempio training.jpg oppure gioco_0.jpg

# dest: cartella di destinazione nella quale salvare le immagini ritagliate dall'immagine originale

# n: dimensione del lato del quadrato dell'immagine, 12 per training.jpg, oppure 3 per l'immagine di gioco_0.jpg, praticamente il numero di colonne della griglia

# w: dimensione di ciascuna cella della griglia in px, ogni immagine estratta avra' tale dimensione, per esempio 100 per immagini di 100x100px

# returnList: se vogliamo che il risultato, ovvero le immagini ritagliate, anziche' essere salvato in una cartella, venga restituito in una lista

def __init__(s, orig, dest = None, n = 12, w = 100, returnList = False):

# impostiamo alcune proprieta' private della classe

s.__return = returnList

s.__lista = [] # questo sara' l'eventuale elenco delle immagini

# preleviamo il percorso assoluto sul quale si trova l'immagine di origine

s.__orig = os.path.abspath(orig)

# se non vogliamo una lista, creiamo il percorso di salvataggio delle immagini

#a tale scopo prendiamo la cartella dell'immagine sorgente e ad essa accodiamo la cartella di destinazione

if not s.__return: s.__dest = os.path.dirname(s.__orig) + "\\" + dest

# se non vogliamo una lista

if not s.__return:

# allora dovremo salvare le immagini in una cartella

# se la cartella di destinazione non esiste

if not os.path.exists(s.__dest):

# allora la creiamo

os.makedirs(s.__dest)

# salviamo i valori in prorieta' private

s.__n = n

s.__w = w

# elaboriamo le immagini

s.elabora()

# per elaborare le immagini dobbiamo ritagliarle da quella originale

# creiamo dunque un metodo per ritagliare le immagini, passando per argomento le coordinate (coor) di ritaglio

# per coordinate si intendono xi, yi e xf, yf di ciascun quadrato di ritaglio (vedere l'articolo per maggiori informazioni)

def ritaglia(s, coor, i):

# leggiamo l'immagine con PIL

img = Image.open(s.__orig)

# ritagliamo l'immagine secondo le coordinate passate

cropped = img.crop(coor)

# se non vogliamo una lista, allora salviamo l'immagine nella destinazione prescelta

if not s.__return: cropped.save(s.__dest + "\\img_" + str(i) + ".jpg")

# altrimenti restituiamo l'immagine come array di NumPy

else: return np.asarray(cropped)

# con questo metodo elaboriamo l'immagine, chiamando ritaglia() per ciascuna cella della griglia

def elabora(s):

# per ciascuna riga

for i in range(s.__n):

#per ciascuna colonna

for j in range(s.__n):

# esegui ritaglia passando le coordinate calcolate e il numero progressivo dell'immagine

img = s.ritaglia( ( j*s.__w , i*s.__w , (j+1) *s.__w , (i+1) * s.__w ) , i * s.__n + j )

# aggiungi l'immagine alla lista delle immagini che si potranno eventualmente restituire

s.__lista.append(img)

# preleviamo la lista delle immagini elaborate

def get(s):

# convertiamo la lista in un array di NumPy

return np.array(s.__lista)

Il metodo ritaglia(s, coor, i) accetta coordinate in (x,y) sull’immagine, le x rappresentano le “colonne”, mentre le y rappresentano le “righe”, nella maniera seguente:

La prima immagine verrà ritagliata con coordinate (0, 0, 100, 100), la seconda con (100, 0, 200, 100) ecc.

Possiamo subito elaborare le immagini di addestramento e di test aggiungendo le seguenti due righe di codice:

ElaboraImmagini("training.jpg","TRAINING",12,100)
ElaboraImmagini("test.jpg","TEST",4,100)

1 2	ElaboraImmagini("training.jpg","TRAINING",12,100) ElaboraImmagini("test.jpg","TEST",4,100)

5. Preleviamo le immagini di addestramento e test, associandoci gli opportuni output

Adesso vogliamo creare la classe che ci consentirà di prelevare le immagini, inserendole in un vettore, ed associare a ciascuna immagine nel vettore l’opportuno output.

Ogni immagine può rappresentare o una O oppure un X, a queste due “etichette” vogliamo associare un valore numerico, che nel mio caso sarà 0 per la O e 1 per la X.

Il comportamento che ci aspettiamo sarà il seguente: train_img, train_desc = CreaDBImmagini(...).get()

train_img conterrà i valori RGB per ciascuna immagine, in una lista di immagini così codificate. Ciascuna immagine è una griglia di pixel, per esempio un’immagine di 3×3 px diventerebbe una matrice di questo tipo [[1,2,3],[4,5,6],[7,8,9]]. I pixel in realtà non sono numerati in questo modo, ma ciascun pixel ha un valore RGB da 0 a 255, per ciascun colore. Quindi se il primo pixel fosse completamente nero al posto dell’1 avremmo [0,0,0], una lista con 3 zeri. Se fosse completamente bianco avremmo [255,255,255], se fosse rosso avremmo [255,0,0] ecc. Questo significa che l’immagine del nostro esempio avrebbe una rappresentazione tridimensionale 3x3x3 diventando così per esempio: [[[0,0,0],[0,0,0],[0,0,0]],[[0,0,0],[255,255,255],[0,0,0]],[[0,0,0],[0,0,0],[0,0,0]]]. In questo caso il pixel centrale, quello che abbiamo numerato come 5, sarebbe bianco e gli altri tutti neri. Se avessimo 100 di queste immagini, avremmo un oggetto di dimensione 100x3x3x3. Ovvero una lista di 100 elementi, di cui ciascun elemento è questa lista, di liste di liste, rappresentante la singola immagine.

train_desc è invece una semplice lista monodimensionale, se avessimo 100 immagini questa sarebbe una lista di 100 elementi. Ogni elemento descrive l’immagine, nel nostro caso se l’immagine corrispondente in train_img fosse una O allora avremo uno 0, nel caso di una X avremo un 1. Sarà quindi una lista tipo [0,1,1,0,0,....]. In questo esempio vorrebbe dire che le immagini in train_img rappresentano in ordine: O, X, X, O, O, ecc.

Tutti gli altri commenti sono nel codice:

class CreaDBImmagini:

    # creiamo delle costanti a livello di classe, che ci permettano di definire l'input tipo nel costruttore
    # e quindi il tipo di immagini che vogliamo tirare fuori, questo e' importante solo ai fini della creazione
    # delle etichette
    TEST = 0
    TRAINING = 1

    # il costruttore accetta 2 argomenti:
    # path: il percorso da cui leggere le immagini
    # tipo: il tipo di etichette da creare in associazione
    def __init__(s, path, tipo = 0):
        s.__path = path
        s.__immagini = []
        s.__descrizioni = []
        s.__tipo = tipo

        s.elabora()

    # elaboriamo le immagini
    def elabora(s):
        # per ogni elemento nella cartella
        for f in os.listdir(s.__path):
            # se si tratta di un file
            if os.path.isfile(s.__path + "\\" + f):
                # leggiamo il file dell'immagine aprendolo con PIL
                img = Image.open(s.__path + "\\" + f)
                # trasformiamo i dati dell'immagine in un array contenente i valori RGB dell'immagine stessa
                bimg = np.asarray(img)
                # aggiungiamo l'immagine all'elenco delle immagini
                s.__immagini.append(bimg)
                # otteniamo il numero dell'immagine, questo lo abbiamo per costruzione dalla precedente classe ElaboraImmagini
                numero = int(f.replace("img_","").replace(".jpg",""))
                # se l'immagine e' del gruppo di test
                if s.__tipo == s.TEST:
                    # siccome le immagini di test sono alternate, tipo O, X, O, X ecc, vuol dire che posso distinguerle
                    # come pari e dispari, quindi i pari saranno 0 e i dispari 1, rispettivamente O e X
                    s.__descrizioni.append( int(numero % 2) )
                # se l'immagine e' del gruppo di addestramento
                if s.__tipo == s.TRAINING:
                    # siccome le immagini di addestramento sono divise a meta', la prima meta' sono O e la seconda sono X
                    # allora sara' sufficiente dividere per la meta' del totale e arrotondare per difetto
                    s.__descrizioni.append( int(np.floor(numero / 72)) )

    # restituisci i due vettori come array di NumPy
    def get(s):
        return (np.array(s.__immagini) , np.array(s.__descrizioni))

class CreaDBImmagini:

# creiamo delle costanti a livello di classe, che ci permettano di definire l'input tipo nel costruttore

# e quindi il tipo di immagini che vogliamo tirare fuori, questo e' importante solo ai fini della creazione

# delle etichette

TEST = 0

TRAINING = 1

# il costruttore accetta 2 argomenti:

# path: il percorso da cui leggere le immagini

# tipo: il tipo di etichette da creare in associazione

def __init__(s, path, tipo = 0):

s.__path = path

s.__immagini = []

s.__descrizioni = []

s.__tipo = tipo

s.elabora()

# elaboriamo le immagini

def elabora(s):

# per ogni elemento nella cartella

for f in os.listdir(s.__path):

# se si tratta di un file

if os.path.isfile(s.__path + "\\" + f):

# leggiamo il file dell'immagine aprendolo con PIL

img = Image.open(s.__path + "\\" + f)

# trasformiamo i dati dell'immagine in un array contenente i valori RGB dell'immagine stessa

bimg = np.asarray(img)

# aggiungiamo l'immagine all'elenco delle immagini

s.__immagini.append(bimg)

# otteniamo il numero dell'immagine, questo lo abbiamo per costruzione dalla precedente classe ElaboraImmagini

numero = int(f.replace("img_","").replace(".jpg",""))

# se l'immagine e' del gruppo di test

if s.__tipo == s.TEST:

# siccome le immagini di test sono alternate, tipo O, X, O, X ecc, vuol dire che posso distinguerle

# come pari e dispari, quindi i pari saranno 0 e i dispari 1, rispettivamente O e X

s.__descrizioni.append( int(numero % 2) )

# se l'immagine e' del gruppo di addestramento

if s.__tipo == s.TRAINING:

# siccome le immagini di addestramento sono divise a meta', la prima meta' sono O e la seconda sono X

# allora sara' sufficiente dividere per la meta' del totale e arrotondare per difetto

s.__descrizioni.append( int(np.floor(numero / 72)) )

# restituisci i due vettori come array di NumPy

def get(s):

return (np.array(s.__immagini) , np.array(s.__descrizioni))

6. Sviluppiamo la classe di gioco

A questo punto sviluppiamo la classe di gioco integrando le precedenti classi.

class GiocoTris:

    # prendiamo come argomenti:
    # orig: cartella dove sono contenuti tutti i giochi
    # train: cartella dove si trovano le immagini di addestramento
    # test: cartella dove si trovano le immagini di test
    # nome_modello: nome della cartella nella quale verra' salvato il modello calcolato
    def __init__(s, orig = "GIOCHI", train = "TRAINING", test = "TEST", nome_modello = "gioco_del_tris"):
        s.__orig = orig
        s.__train = train
        s.__test = test
        s.__nome_modello = nome_modello
        s.__modello = None
        # leggiamo l'elenco dei file nella cartella orig, solo se sono dei file, e teniamoli come partite possibili
        s.__partite = [f for f in os.listdir(orig) if os.path.isfile(orig + "\\" + f)]

        # se il modello salvato esiste (ovvero se esiste la cartella)
        if os.path.exists(s.__nome_modello):
            # caricare il modello salvato
            s.__modello = keras.models.load_model(s.__nome_modello)
            
    #restituisce la lista dei file delle partite
    def getGiochi(s):
        return s.__partite

    # prepara il modello
    def prepara(s):

        # prepara il modello se il modello non esiste, ovvero non e' stato caricato
        if s.__modello is None:

            # preleva le immagini di addestramento e le relative descrizioni, ossia gli output noti
            train_img, train_desc = CreaDBImmagini(s.__train,CreaDBImmagini.TRAINING).get()

            # prepara il modello
            s.__modello = keras.Sequential([
                keras.layers.Flatten(input_shape=(100, 100, 3)),
                keras.layers.Dense(128, activation='relu'),
                keras.layers.Dense(2, activation='softmax')
            ])

            # compila il modello
            s.__modello.compile(optimizer="adam",
                  loss='sparse_categorical_crossentropy',
                  metrics=['accuracy'])

            # allena il modello con le immagini scelte in precedenza
            s.__modello.fit(train_img, train_desc, epochs=20)            

            # salva il modello
            s.__modello.save(s.__nome_modello)

    # valuta accuratezza del modello con immagini di test
    def getAccuracy(s):

        # preleva immagini e output di test
        test_img, test_desc = CreaDBImmagini(s.__test,CreaDBImmagini.TEST).get()

        # calcola le perdite e l'accuratezza sulle immagini di test
        s.__test_loss, s.__test_acc = s.__modello.evaluate(test_img, test_desc, verbose=0)
        
        return s.__test_acc

    # valuta uno specifico gioco, scelto come posizione tra le partite possibili
    def getImmagine(s, pos):
        # elabora l'immagine del gioco compiuto
        gioco = ElaboraImmagini(orig = s.__orig + "\\" + s.__partite[pos], n = 3, w = 100, returnList = True).get()

        # predici i risultati in termini percentuali
        previsione = s.__modello.predict(gioco)
        # prepara l'output reinterpretato
        s.__risultato = []
        # per ciascun valore delle previsioni
        for p in previsione:
            # se i valori sono vicini per un parametro arbitrario di confidenza, allora la casella e' vuota
            # per esempio se i valori sono 51% e 49%
            if abs(p[0]-p[1]) < 0.1: v = 0
            # se il primo valore supera il secondo allora abbiamo uno O
            elif p[0] > p[1]: v = 1
            # altrimenti abbiamo una X
            else: v = 2
            # aggiungi il valore al risultato
            s.__risultato.append(v)
        # ottieni il vincitore
        vincitore = s.getVincitore( s.__risultato )
        # restituisci il vincitore
        return vincitore

    # calcola il vincitore
    def getVincitore(s,vect):
        for i in range(0,9,3):
            if vect[i] == vect[i+1] == vect[i+2] and vect[i] != 0: return vect[i]
        for i in range(3):
            if vect[i] == vect[i+3] == vect[i+6] and vect[i] != 0: return vect[i]
        if (vect[0] == vect[4] == vect[8] and vect[0] != 0) or (vect[2] == vect[4] == vect[6] and vect[2] != 0): return vect[4]

    # mostra la griglia di gioco
    def stampaGioco(s):
        symb = ["-","O","X"]
        for k, r in enumerate(s.__risultato):
            if k > 0 and not k % 3: print()
            print(symb[r],end=" ")
        print()

100

101

102

103

class GiocoTris:

# prendiamo come argomenti:

# orig: cartella dove sono contenuti tutti i giochi

# train: cartella dove si trovano le immagini di addestramento

# test: cartella dove si trovano le immagini di test

# nome_modello: nome della cartella nella quale verra' salvato il modello calcolato

def __init__(s, orig = "GIOCHI", train = "TRAINING", test = "TEST", nome_modello = "gioco_del_tris"):

s.__orig = orig

s.__train = train

s.__test = test

s.__nome_modello = nome_modello

s.__modello = None

# leggiamo l'elenco dei file nella cartella orig, solo se sono dei file, e teniamoli come partite possibili

s.__partite = [f for f in os.listdir(orig) if os.path.isfile(orig + "\\" + f)]

# se il modello salvato esiste (ovvero se esiste la cartella)

if os.path.exists(s.__nome_modello):

# caricare il modello salvato

s.__modello = keras.models.load_model(s.__nome_modello)

#restituisce la lista dei file delle partite

def getGiochi(s):

return s.__partite

# prepara il modello

def prepara(s):

# prepara il modello se il modello non esiste, ovvero non e' stato caricato

if s.__modello is None:

# preleva le immagini di addestramento e le relative descrizioni, ossia gli output noti

train_img, train_desc = CreaDBImmagini(s.__train,CreaDBImmagini.TRAINING).get()

# prepara il modello

s.__modello = keras.Sequential([

keras.layers.Flatten(input_shape=(100, 100, 3)),

keras.layers.Dense(128, activation='relu'),

keras.layers.Dense(2, activation='softmax')

])

# compila il modello

s.__modello.compile(optimizer="adam",

loss='sparse_categorical_crossentropy',

metrics=['accuracy'])

# allena il modello con le immagini scelte in precedenza

s.__modello.fit(train_img, train_desc, epochs=20)

# salva il modello

s.__modello.save(s.__nome_modello)

# valuta accuratezza del modello con immagini di test

def getAccuracy(s):

# preleva immagini e output di test

test_img, test_desc = CreaDBImmagini(s.__test,CreaDBImmagini.TEST).get()

# calcola le perdite e l'accuratezza sulle immagini di test

s.__test_loss, s.__test_acc = s.__modello.evaluate(test_img, test_desc, verbose=0)

return s.__test_acc

# valuta uno specifico gioco, scelto come posizione tra le partite possibili

def getImmagine(s, pos):

# elabora l'immagine del gioco compiuto

gioco = ElaboraImmagini(orig = s.__orig + "\\" + s.__partite[pos], n = 3, w = 100, returnList = True).get()

# predici i risultati in termini percentuali

previsione = s.__modello.predict(gioco)

# prepara l'output reinterpretato

s.__risultato = []

# per ciascun valore delle previsioni

for p in previsione:

# se i valori sono vicini per un parametro arbitrario di confidenza, allora la casella e' vuota

# per esempio se i valori sono 51% e 49%

if abs(p[0]-p[1]) < 0.1: v = 0

# se il primo valore supera il secondo allora abbiamo uno O

elif p[0] > p[1]: v = 1

# altrimenti abbiamo una X

else: v = 2

# aggiungi il valore al risultato

s.__risultato.append(v)

# ottieni il vincitore

vincitore = s.getVincitore( s.__risultato )

# restituisci il vincitore

return vincitore

# calcola il vincitore

def getVincitore(s,vect):

for i in range(0,9,3):

if vect[i] == vect[i+1] == vect[i+2] and vect[i] != 0: return vect[i]

for i in range(3):

if vect[i] == vect[i+3] == vect[i+6] and vect[i] != 0: return vect[i]

if (vect[0] == vect[4] == vect[8] and vect[0] != 0) or (vect[2] == vect[4] == vect[6] and vect[2] != 0): return vect[4]

# mostra la griglia di gioco

def stampaGioco(s):

symb = ["-","O","X"]

for k, r in enumerate(s.__risultato):

if k > 0 and not k % 3: print()

print(symb[r],end=" ")

print()

Anche su questo facciamo un paio di appunti. Quando calcoliamo le previsioni con previsione = s.__modello.predict(gioco) otteniamo una lista di liste di probabilità. Ogni sub-lista contiene tante probabilità quanti sono i neuroni (o nodi) impostati nell’ultimo layer del modello. Nel nostro caso all’istruzione keras.layers.Dense(2, activation='softmax') abbiamo impostato 2 neuroni, quindi il vettore di previsione conterrà un elenco di liste del tipo [p1, p2], dove p1 e p2 sono le probabilità dell’output 0 e dell’output 1 (che ricordiamoci corrispondono a O e a X, rispettivamente). Il risultato di previsione sarà qualcosa del tipo [[1. 0.],[0.51 0.49], [0. 1.]]. Nel caso specifico vorrebbe dire che secondo il ML la prima immagina è una O, poi uno spazio vuoto, poi una X. Per quanto riguarda l’uso di softmax e relu fare riferimento a questa pagina.

Per i dettagli sull’optimizer Adam fare riferimento a questa pagina.

Il calcolo della griglia di vittoria è molto semplice, perché abbiamo un vettore lineare e non una matrice (o griglia vera e propria). In questo caso una partita come quella del gioco_1.jpg sarà rappresentata da una lista di 0, 1 e 2, in questo modo (dove 0 = vuoto, 1 = O, 2 = X): [2, 2, 1, 2, 1, 0, 2, 1, 1]

Quando il primo valore è diverso da 0, quindi da vuoto, basta controllare che a distanza di 3 siano uguali, come qui: [2, 2, 1, 2, 1, 0, 2, 1, 1]

In questo modo stiamo controllando le colonne.

Per controllare le righe basta verificare le triplette, così: [2, 2, 1, 2, 1, 0, 2, 1, 1]

7. Chiudiamo il programma

Infine costruiamo il ciclo while per poter far usare il programma:

gt = GiocoTris(orig = "GIOCHI", train = "TRAINING", test = "TEST", nome_modello = "gioco_del_tris")
gt.prepara()

while True:

    print("-- gioco del tris --")
    print('Test accuracy:', gt.getAccuracy())
    print("scegli la partita (-1 esci):")
    for k, n in enumerate(gt.getGiochi()):
        print("{0}. gioco {0}".format(k))
    print("> ",end="")
    partita = int(input())

    if partita == -1: break

    if partita >= 0 and partita <= 9:
        vincitore = gt.getImmagine( partita )
        if vincitore == 1: print("Ha vinto O")
        elif vincitore == 2: print("Ha vinto X")
        else: print("Nessun vincitore")

        gt.stampaGioco()

gt = GiocoTris(orig = "GIOCHI", train = "TRAINING", test = "TEST", nome_modello = "gioco_del_tris")

gt.prepara()

while True:

print("-- gioco del tris --")

print('Test accuracy:', gt.getAccuracy())

print("scegli la partita (-1 esci):")

for k, n in enumerate(gt.getGiochi()):

print("{0}. gioco {0}".format(k))

print("> ",end="")

partita = int(input())

if partita == -1: break

if partita >= 0 and partita <= 9:

vincitore = gt.getImmagine( partita )

if vincitore == 1: print("Ha vinto O")

elif vincitore == 2: print("Ha vinto X")

else: print("Nessun vincitore")

gt.stampaGioco()

Per completezza riporto di seguito l’intero codice di programmazione:

from __future__ import absolute_import, division, print_function, unicode_literals

from PIL import Image
import numpy as np
import os

import tensorflow as tf
from tensorflow import keras
import matplotlib.pyplot as plt

class ElaboraImmagini:

    # al costruttore della classe passiamo i seguenti argomenti:
    # orig: file dell'immagine originale da elaborare, per esempio training.jpg oppure gioco_0.jpg
    # dest: cartella di destinazione nella quale salvare le immagini ritagliate dall'immagine originale
    # n: dimensione del lato del quadrato dell'immagine, 12 per training.jpg, oppure 3 per l'immagine di gioco_0.jpg, praticamente il numero di colonne della griglia
    # w: dimensione di ciascuna cella della griglia in px, ogni immagine estratta avra' tale dimensione, per esempio 100 per immagini di 100x100px
    # returnList: se vogliamo che il risultato, ovvero le immagini ritagliate, anziche' essere salvato in una cartella, venga restituito in una lista
    def __init__(s, orig, dest = None, n = 12, w = 100, returnList = False):
        # impostiamo alcune proprieta' private della classe
        s.__return = returnList
        s.__lista = [] # questo sara' l'eventuale elenco delle immagini
        # preleviamo il percorso assoluto sul quale si trova l'immagine di origine
        s.__orig = os.path.abspath(orig)
        # se non vogliamo una lista, creiamo il percorso di salvataggio delle immagini
        #a tale scopo prendiamo la cartella dell'immagine sorgente e ad essa accodiamo la cartella di destinazione
        if not s.__return: s.__dest = os.path.dirname(s.__orig) + "\\" + dest

        # se non vogliamo una lista
        if not s.__return:
            # allora dovremo salvare le immagini in una cartella
            # se la cartella di destinazione non esiste
            if not os.path.exists(s.__dest):
                # allora la creiamo
                os.makedirs(s.__dest)

        # salviamo i valori in prorieta' private
        s.__n = n
        s.__w = w

        # elaboriamo le immagini
        s.elabora()

    # per elaborare le immagini dobbiamo ritagliarle da quella originale
    # creiamo dunque un metodo per ritagliare le immagini, passando per argomento le coordinate (coor) di ritaglio
    # per coordinate si intendono xi, yi e xf, yf di ciascun quadrato di ritaglio (vedere l'articolo per maggiori informazioni)
    def ritaglia(s, coor, i):
        # leggiamo l'immagine con PIL
        img = Image.open(s.__orig)
        # ritagliamo l'immagine secondo le coordinate passate
        cropped = img.crop(coor)
        # se non vogliamo una lista, allora salviamo l'immagine nella destinazione prescelta
        if not s.__return: cropped.save(s.__dest + "\\img_" + str(i) + ".jpg")
        # altrimenti restituiamo l'immagine come array di NumPy
        else: return np.asarray(cropped)

    # con questo metodo elaboriamo l'immagine, chiamando ritaglia() per ciascuna cella della griglia
    def elabora(s):
        # per ciascuna riga
        for i in range(s.__n):
            #per ciascuna colonna
            for j in range(s.__n):
                # esegui ritaglia passando le coordinate calcolate e il numero progressivo dell'immagine
                img = s.ritaglia( ( j*s.__w , i*s.__w , (j+1) *s.__w , (i+1) * s.__w ) , i * s.__n + j )
                # aggiungi l'immagine alla lista delle immagini che si potranno eventualmente restituire
                s.__lista.append(img)

    # preleviamo la lista delle immagini elaborate
    def get(s):
        # convertiamo la lista in un array di NumPy
        return np.array(s.__lista)

class CreaDBImmagini:

    # creiamo delle costanti a livello di classe, che ci permettano di definire l'input tipo nel costruttore
    # e quindi il tipo di immagini che vogliamo tirare fuori, questo e' importante solo ai fini della creazione
    # delle etichette
    TEST = 0
    TRAINING = 1

    # il costruttore accetta 2 argomenti:
    # path: il percorso da cui leggere le immagini
    # tipo: il tipo di etichette da creare in associazione
    def __init__(s, path, tipo = 0):
        s.__path = path
        s.__immagini = []
        s.__descrizioni = []
        s.__tipo = tipo

        s.elabora()

    # elaboriamo le immagini
    def elabora(s):
        # per ogni elemento nella cartella
        for f in os.listdir(s.__path):
            # se si tratta di un file
            if os.path.isfile(s.__path + "\\" + f):
                # leggiamo il file dell'immagine aprendolo con PIL
                img = Image.open(s.__path + "\\" + f)
                # trasformiamo i dati dell'immagine in un array contenente i valori RGB dell'immagine stessa
                bimg = np.asarray(img)
                # aggiungiamo l'immagine all'elenco delle immagini
                s.__immagini.append(bimg)
                # otteniamo il numero dell'immagine, questo lo abbiamo per costruzione dalla precedente classe ElaboraImmagini
                numero = int(f.replace("img_","").replace(".jpg",""))
                # se l'immagine e' del gruppo di test
                if s.__tipo == s.TEST:
                    # siccome le immagini di test sono alternate, tipo O, X, O, X ecc, vuol dire che posso distinguerle
                    # come pari e dispari, quindi i pari saranno 0 e i dispari 1, rispettivamente O e X
                    s.__descrizioni.append( int(numero % 2) )
                # se l'immagine e' del gruppo di addestramento
                if s.__tipo == s.TRAINING:
                    # siccome le immagini di addestramento sono divise a meta', la prima meta' sono O e la seconda sono X
                    # allora sara' sufficiente dividere per la meta' del totale e arrotondare per difetto
                    s.__descrizioni.append( int(np.floor(numero / 72)) )

    # restituisci i due vettori come array di NumPy
    def get(s):
        return (np.array(s.__immagini) , np.array(s.__descrizioni))

class GiocoTris:

    # prendiamo come argomenti:
    # orig: cartella dove sono contenuti tutti i giochi
    # train: cartella dove si trovano le immagini di addestramento
    # test: cartella dove si trovano le immagini di test
    # nome_modello: nome della cartella nella quale verra' salvato il modello calcolato
    def __init__(s, orig = "GIOCHI", train = "TRAINING", test = "TEST", nome_modello = "gioco_del_tris"):
        s.__orig = orig
        s.__train = train
        s.__test = test
        s.__nome_modello = nome_modello
        s.__modello = None
        # leggiamo l'elenco dei file nella cartella orig, solo se sono dei file, e teniamoli come partite possibili
        s.__partite = [f for f in os.listdir(orig) if os.path.isfile(orig + "\\" + f)]

        # se il modello salvato esiste (ovvero se esiste la cartella)
        if os.path.exists(s.__nome_modello):
            # caricare il modello salvato
            s.__modello = keras.models.load_model(s.__nome_modello)
            
    #restituisce la lista dei file delle partite
    def getGiochi(s):
        return s.__partite

    # prepara il modello
    def prepara(s):

        # prepara il modello se il modello non esiste, ovvero non e' stato caricato
        if s.__modello is None:

            # preleva le immagini di addestramento e le relative descrizioni, ossia gli output noti
            train_img, train_desc = CreaDBImmagini(s.__train,CreaDBImmagini.TRAINING).get()

            # prepara il modello
            s.__modello = keras.Sequential([
                keras.layers.Flatten(input_shape=(100, 100, 3)),
                keras.layers.Dense(128, activation='relu'),
                keras.layers.Dense(2, activation='softmax')
            ])

            # compila il modello
            s.__modello.compile(optimizer="adam",
                  loss='sparse_categorical_crossentropy',
                  metrics=['accuracy'])

            # allena il modello con le immagini scelte in precedenza
            s.__modello.fit(train_img, train_desc, epochs=20)            

            # salva il modello
            s.__modello.save(s.__nome_modello)

    # valuta accuratezza del modello con immagini di test
    def getAccuracy(s):

        # preleva immagini e output di test
        test_img, test_desc = CreaDBImmagini(s.__test,CreaDBImmagini.TEST).get()

        # calcola le perdite e l'accuratezza sulle immagini di test
        s.__test_loss, s.__test_acc = s.__modello.evaluate(test_img, test_desc, verbose=0)
        
        return s.__test_acc

    # valuta uno specifico gioco, scelto come posizione tra le partite possibili
    def getImmagine(s, pos):
        # elabora l'immagine del gioco compiuto
        gioco = ElaboraImmagini(orig = s.__orig + "\\" + s.__partite[pos], n = 3, w = 100, returnList = True).get()

        # predici i risultati in termini percentuali
        previsione = s.__modello.predict(gioco)
        # prepara l'output reinterpretato
        s.__risultato = []
        # per ciascun valore delle previsioni
        for p in previsione:
            # se i valori sono vicini per un parametro arbitrario di confidenza, allora la casella e' vuota
            # per esempio se i valori sono 51% e 49%
            if abs(p[0]-p[1]) < 0.1: v = 0
            # se il primo valore supera il secondo allora abbiamo uno O
            elif p[0] > p[1]: v = 1
            # altrimenti abbiamo una X
            else: v = 2
            # aggiungi il valore al risultato
            s.__risultato.append(v)
        # ottieni il vincitore
        vincitore = s.getVincitore( s.__risultato )
        # restituisci il vincitore
        return vincitore

    # calcola il vincitore
    def getVincitore(s,vect):
        for i in range(0,9,3):
            if vect[i] == vect[i+1] == vect[i+2] and vect[i] != 0: return vect[i]
        for i in range(3):
            if vect[i] == vect[i+3] == vect[i+6] and vect[i] != 0: return vect[i]
        if (vect[0] == vect[4] == vect[8] and vect[0] != 0) or (vect[2] == vect[4] == vect[6] and vect[2] != 0): return vect[4]

    # mostra la griglia di gioco
    def stampaGioco(s):
        symb = ["-","O","X"]
        for k, r in enumerate(s.__risultato):
            if k > 0 and not k % 3: print()
            print(symb[r],end=" ")
        print()


ElaboraImmagini("training.jpg","TRAINING",12,100)
ElaboraImmagini("test.jpg","TEST",4,100)


gt = GiocoTris(orig = "GIOCHI", train = "TRAINING", test = "TEST", nome_modello = "gioco_del_tris")
gt.prepara()

while True:

    print("-- gioco del tris --")
    print('Test accuracy:', gt.getAccuracy())
    print("scegli la partita (-1 esci):")
    for k, n in enumerate(gt.getGiochi()):
        print("{0}. gioco {0}".format(k))
    print("> ",end="")
    partita = int(input())

    if partita == -1: break

    if partita >= 0 and partita <= 9:
        vincitore = gt.getImmagine( partita )
        if vincitore == 1: print("Ha vinto O")
        elif vincitore == 2: print("Ha vinto X")
        else: print("Nessun vincitore")

        gt.stampaGioco()

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

from __future__ import absolute_import, division, print_function, unicode_literals

from PIL import Image

import numpy as np

import os

import tensorflow as tf

from tensorflow import keras

import matplotlib.pyplot as plt

class ElaboraImmagini:

# al costruttore della classe passiamo i seguenti argomenti:

# orig: file dell'immagine originale da elaborare, per esempio training.jpg oppure gioco_0.jpg

# dest: cartella di destinazione nella quale salvare le immagini ritagliate dall'immagine originale

# n: dimensione del lato del quadrato dell'immagine, 12 per training.jpg, oppure 3 per l'immagine di gioco_0.jpg, praticamente il numero di colonne della griglia

# w: dimensione di ciascuna cella della griglia in px, ogni immagine estratta avra' tale dimensione, per esempio 100 per immagini di 100x100px

# returnList: se vogliamo che il risultato, ovvero le immagini ritagliate, anziche' essere salvato in una cartella, venga restituito in una lista

def __init__(s, orig, dest = None, n = 12, w = 100, returnList = False):

# impostiamo alcune proprieta' private della classe

s.__return = returnList

s.__lista = [] # questo sara' l'eventuale elenco delle immagini

# preleviamo il percorso assoluto sul quale si trova l'immagine di origine

s.__orig = os.path.abspath(orig)

# se non vogliamo una lista, creiamo il percorso di salvataggio delle immagini

#a tale scopo prendiamo la cartella dell'immagine sorgente e ad essa accodiamo la cartella di destinazione

if not s.__return: s.__dest = os.path.dirname(s.__orig) + "\\" + dest

# se non vogliamo una lista

if not s.__return:

# allora dovremo salvare le immagini in una cartella

# se la cartella di destinazione non esiste

if not os.path.exists(s.__dest):

# allora la creiamo

os.makedirs(s.__dest)

# salviamo i valori in prorieta' private

s.__n = n

s.__w = w

# elaboriamo le immagini

s.elabora()

# per elaborare le immagini dobbiamo ritagliarle da quella originale

# creiamo dunque un metodo per ritagliare le immagini, passando per argomento le coordinate (coor) di ritaglio

# per coordinate si intendono xi, yi e xf, yf di ciascun quadrato di ritaglio (vedere l'articolo per maggiori informazioni)

def ritaglia(s, coor, i):

# leggiamo l'immagine con PIL

img = Image.open(s.__orig)

# ritagliamo l'immagine secondo le coordinate passate

cropped = img.crop(coor)

# se non vogliamo una lista, allora salviamo l'immagine nella destinazione prescelta

if not s.__return: cropped.save(s.__dest + "\\img_" + str(i) + ".jpg")

# altrimenti restituiamo l'immagine come array di NumPy

else: return np.asarray(cropped)

# con questo metodo elaboriamo l'immagine, chiamando ritaglia() per ciascuna cella della griglia

def elabora(s):

# per ciascuna riga

for i in range(s.__n):

#per ciascuna colonna

for j in range(s.__n):

# esegui ritaglia passando le coordinate calcolate e il numero progressivo dell'immagine

img = s.ritaglia( ( j*s.__w , i*s.__w , (j+1) *s.__w , (i+1) * s.__w ) , i * s.__n + j )

# aggiungi l'immagine alla lista delle immagini che si potranno eventualmente restituire

s.__lista.append(img)

# preleviamo la lista delle immagini elaborate

def get(s):

# convertiamo la lista in un array di NumPy

return np.array(s.__lista)

class CreaDBImmagini:

# creiamo delle costanti a livello di classe, che ci permettano di definire l'input tipo nel costruttore

# e quindi il tipo di immagini che vogliamo tirare fuori, questo e' importante solo ai fini della creazione

# delle etichette

TEST = 0

TRAINING = 1

# il costruttore accetta 2 argomenti:

# path: il percorso da cui leggere le immagini

# tipo: il tipo di etichette da creare in associazione

def __init__(s, path, tipo = 0):

s.__path = path

s.__immagini = []

s.__descrizioni = []

s.__tipo = tipo

s.elabora()

# elaboriamo le immagini

def elabora(s):

# per ogni elemento nella cartella

for f in os.listdir(s.__path):

# se si tratta di un file

if os.path.isfile(s.__path + "\\" + f):

# leggiamo il file dell'immagine aprendolo con PIL

img = Image.open(s.__path + "\\" + f)

# trasformiamo i dati dell'immagine in un array contenente i valori RGB dell'immagine stessa

bimg = np.asarray(img)

# aggiungiamo l'immagine all'elenco delle immagini

s.__immagini.append(bimg)

# otteniamo il numero dell'immagine, questo lo abbiamo per costruzione dalla precedente classe ElaboraImmagini

numero = int(f.replace("img_","").replace(".jpg",""))

# se l'immagine e' del gruppo di test

if s.__tipo == s.TEST:

# siccome le immagini di test sono alternate, tipo O, X, O, X ecc, vuol dire che posso distinguerle

# come pari e dispari, quindi i pari saranno 0 e i dispari 1, rispettivamente O e X

s.__descrizioni.append( int(numero % 2) )

# se l'immagine e' del gruppo di addestramento

if s.__tipo == s.TRAINING:

# siccome le immagini di addestramento sono divise a meta', la prima meta' sono O e la seconda sono X

# allora sara' sufficiente dividere per la meta' del totale e arrotondare per difetto

s.__descrizioni.append( int(np.floor(numero / 72)) )

# restituisci i due vettori come array di NumPy

def get(s):

return (np.array(s.__immagini) , np.array(s.__descrizioni))

class GiocoTris:

# prendiamo come argomenti:

# orig: cartella dove sono contenuti tutti i giochi

# train: cartella dove si trovano le immagini di addestramento

# test: cartella dove si trovano le immagini di test

# nome_modello: nome della cartella nella quale verra' salvato il modello calcolato

def __init__(s, orig = "GIOCHI", train = "TRAINING", test = "TEST", nome_modello = "gioco_del_tris"):

s.__orig = orig

s.__train = train

s.__test = test

s.__nome_modello = nome_modello

s.__modello = None

# leggiamo l'elenco dei file nella cartella orig, solo se sono dei file, e teniamoli come partite possibili

s.__partite = [f for f in os.listdir(orig) if os.path.isfile(orig + "\\" + f)]

# se il modello salvato esiste (ovvero se esiste la cartella)

if os.path.exists(s.__nome_modello):

# caricare il modello salvato

s.__modello = keras.models.load_model(s.__nome_modello)

#restituisce la lista dei file delle partite

def getGiochi(s):

return s.__partite

# prepara il modello

def prepara(s):

# prepara il modello se il modello non esiste, ovvero non e' stato caricato

if s.__modello is None:

# preleva le immagini di addestramento e le relative descrizioni, ossia gli output noti

train_img, train_desc = CreaDBImmagini(s.__train,CreaDBImmagini.TRAINING).get()

# prepara il modello

s.__modello = keras.Sequential([

keras.layers.Flatten(input_shape=(100, 100, 3)),

keras.layers.Dense(128, activation='relu'),

keras.layers.Dense(2, activation='softmax')

])

# compila il modello

s.__modello.compile(optimizer="adam",

loss='sparse_categorical_crossentropy',

metrics=['accuracy'])

# allena il modello con le immagini scelte in precedenza

s.__modello.fit(train_img, train_desc, epochs=20)

# salva il modello

s.__modello.save(s.__nome_modello)

# valuta accuratezza del modello con immagini di test

def getAccuracy(s):

# preleva immagini e output di test

test_img, test_desc = CreaDBImmagini(s.__test,CreaDBImmagini.TEST).get()

# calcola le perdite e l'accuratezza sulle immagini di test

s.__test_loss, s.__test_acc = s.__modello.evaluate(test_img, test_desc, verbose=0)

return s.__test_acc

# valuta uno specifico gioco, scelto come posizione tra le partite possibili

def getImmagine(s, pos):

# elabora l'immagine del gioco compiuto

gioco = ElaboraImmagini(orig = s.__orig + "\\" + s.__partite[pos], n = 3, w = 100, returnList = True).get()

# predici i risultati in termini percentuali

previsione = s.__modello.predict(gioco)

# prepara l'output reinterpretato

s.__risultato = []

# per ciascun valore delle previsioni

for p in previsione:

# se i valori sono vicini per un parametro arbitrario di confidenza, allora la casella e' vuota

# per esempio se i valori sono 51% e 49%

if abs(p[0]-p[1]) < 0.1: v = 0

# se il primo valore supera il secondo allora abbiamo uno O

elif p[0] > p[1]: v = 1

# altrimenti abbiamo una X

else: v = 2

# aggiungi il valore al risultato

s.__risultato.append(v)

# ottieni il vincitore

vincitore = s.getVincitore( s.__risultato )

# restituisci il vincitore

return vincitore

# calcola il vincitore

def getVincitore(s,vect):

for i in range(0,9,3):

if vect[i] == vect[i+1] == vect[i+2] and vect[i] != 0: return vect[i]

for i in range(3):

if vect[i] == vect[i+3] == vect[i+6] and vect[i] != 0: return vect[i]

if (vect[0] == vect[4] == vect[8] and vect[0] != 0) or (vect[2] == vect[4] == vect[6] and vect[2] != 0): return vect[4]

# mostra la griglia di gioco

def stampaGioco(s):

symb = ["-","O","X"]

for k, r in enumerate(s.__risultato):

if k > 0 and not k % 3: print()

print(symb[r],end=" ")

print()

ElaboraImmagini("training.jpg","TRAINING",12,100)

ElaboraImmagini("test.jpg","TEST",4,100)

gt = GiocoTris(orig = "GIOCHI", train = "TRAINING", test = "TEST", nome_modello = "gioco_del_tris")

gt.prepara()

while True:

print("-- gioco del tris --")

print('Test accuracy:', gt.getAccuracy())

print("scegli la partita (-1 esci):")

for k, n in enumerate(gt.getGiochi()):

print("{0}. gioco {0}".format(k))

print("> ",end="")

partita = int(input())

if partita == -1: break

if partita >= 0 and partita <= 9:

vincitore = gt.getImmagine( partita )

if vincitore == 1: print("Ha vinto O")

elif vincitore == 2: print("Ha vinto X")

else: print("Nessun vincitore")

gt.stampaGioco()

Vedi articolo

2 Luglio 2020 1 commento

[python] Esercizio su funzioni ricorsive e calcolo del percorso minore possibile

Immaginiamo di avere la seguente situazione: su una griglia rettangolare abbiamo due punti, A e B e vogliamo calcolare il minore percorso possibile per arrivare da A a B, evitando degli ostacoli. Da una cella all’altra ci si può spostare solamente in verticale ed orizzontale.

Possiamo schematizzare il problema in qualcosa di simile.

Anzitutto impostiamo le variabili necessarie:

n = 10 # numero di colonne
m = 10 # numero di righe
x = 10 # numero di ostacoli
pi = [] # punto di partenza
pf = [] # punto di arrivo
percorsi = [] # tutti i percorsi possibili
minlen = 0 # lunghezza trovata

n = 10 # numero di colonne

m = 10 # numero di righe

x = 10 # numero di ostacoli

pi = [] # punto di partenza

pf = [] # punto di arrivo

percorsi = [] # tutti i percorsi possibili

minlen = 0 # lunghezza trovata

In particolare faccio notare che terremo tutti i percorsi in una lista percorsi = [] e vogliamo anche tenere traccia della minima lunghezza trovata con minlen. Questo accorgimento, come vedremo successivamente, ci servirà per ridurre notevolmente la quantità di calcoli da dover effettuare, eliminando tutti i percorsi che via via dovessero rivelarsi più lunghi del minimo percorso trovato (fino a quel momento).

A questo punto generiamo la matrice del mondo:

mtrx = [["-" for c in range(m)] for r in range(n)]

1	mtrx = [["-" for c in range(m)] for r in range(n)]

Adesso scriviamo la funzione per popolare il mondo di blocchi, le X del disegno precedente. Per farlo utilizzeremo la libreria random, per cui ricordiamoci di importarla all’inizio con import random

def blocchi():
    t = 0
    while t < x:
        tc = random.randint(0, m-1)
        tr = random.randint(0, n-1)
        if mtrx[tr][tc] != "X":
            mtrx[tr][tc] = "X"
            t += 1

def blocchi():

t = 0

while t < x:

tc = random.randint(0, m-1)

tr = random.randint(0, n-1)

if mtrx[tr][tc] != "X":

mtrx[tr][tc] = "X"

t += 1

Utilizziamo random.randint per generare una posizione casuale su righe e colonne per i blocchi, verifichiamo che tale punto non sia già occupato da un blocco, in tal caso procediamo ad aggiungerlo.

In modo analogo creiamo un metodo che aggiunga la posizione iniziale A e quella finale B, registrandole nelle rispettive variabili.

def inizio():
    global pi, pf
    t = 0
    while t < 2:
        tc = random.randint(0, m-1)
        tr = random.randint(0, n-1)
        if mtrx[tr][tc] == "-":
            if t == 0:
                mtrx[tr][tc] = "A"
                pi = [tr,tc]
            else:
                mtrx[tr][tc] = "B"
                pf = [tr,tc]
            t += 1

def inizio():

global pi, pf

t = 0

while t < 2:

tc = random.randint(0, m-1)

tr = random.randint(0, n-1)

if mtrx[tr][tc] == "-":

if t == 0:

mtrx[tr][tc] = "A"

pi = [tr,tc]

else:

mtrx[tr][tc] = "B"

pf = [tr,tc]

t += 1

Per trovare il percorso procediamo nella maniera seguente:

def trova(si,percorso=[]):
    # usiamo minlen come variabile globale
    global minlen
    # se la posizione corrente rientra nella matrice, allora procediamo
    if si[0] >= 0 and si[0] < n and si[1] >= 0 and si[1] < m:
        # se la posizione non e' occupata da un blocco e non e' gia' presente nel percorso procediamo
        if mtrx[si[0]][si[1]] != "X" and si not in percorso:
            # aggiungiamo la posizione
            percorso.append(si)
            # se il percorso supera la minima lunghezza trovata e tale lunghezza e' maggiore di 0, interrompiamo la ricorsione
            if len(percorso) > minlen and minlen > 0: return
            # se la posizione e' occupata dalla B allora abbiamo trovato la fine
            if mtrx[si[0]][si[1]] == "B":
                # se la lunghezza del percorso trovato e' minore della minore trovata
                # fino a quel momento, oppure la minore lunghezza e' a 0, aggiorniamo la lunghezza minore
                if len(percorso) < minlen or minlen == 0: minlen = len(percorso)
                #aggiungiamo il percorso ai percorsi trovati
                percorsi.append([]+percorso)
            #altrimenti eseguiamo la funzione sulle caselle circostanti
            else:
                trova([si[0]-1,si[1]],[]+percorso)
                trova([si[0]+1,si[1]],[]+percorso)
                trova([si[0],si[1]-1],[]+percorso)
                trova([si[0],si[1]+1],[]+percorso)

def trova(si,percorso=[]):

# usiamo minlen come variabile globale

global minlen

# se la posizione corrente rientra nella matrice, allora procediamo

if si[0] >= 0 and si[0] < n and si[1] >= 0 and si[1] < m:

# se la posizione non e' occupata da un blocco e non e' gia' presente nel percorso procediamo

if mtrx[si[0]][si[1]] != "X" and si not in percorso:

# aggiungiamo la posizione

percorso.append(si)

# se il percorso supera la minima lunghezza trovata e tale lunghezza e' maggiore di 0, interrompiamo la ricorsione

if len(percorso) > minlen and minlen > 0: return

# se la posizione e' occupata dalla B allora abbiamo trovato la fine

if mtrx[si[0]][si[1]] == "B":

# se la lunghezza del percorso trovato e' minore della minore trovata

# fino a quel momento, oppure la minore lunghezza e' a 0, aggiorniamo la lunghezza minore

if len(percorso) < minlen or minlen == 0: minlen = len(percorso)

#aggiungiamo il percorso ai percorsi trovati

percorsi.append([]+percorso)

#altrimenti eseguiamo la funzione sulle caselle circostanti

else:

trova([si[0]-1,si[1]],[]+percorso)

trova([si[0]+1,si[1]],[]+percorso)

trova([si[0],si[1]-1],[]+percorso)

trova([si[0],si[1]+1],[]+percorso)

Faccio notare una peculiarità, legata al modo in cui Python tratta le liste. Per passare il percorso attuale, copiandolo, alla funzione medesima, dobbiamo usare un piccolo trucco scrivendo []+percorso. In questo modo evitiamo che il percorso sia passato per riferimento, forzando il programma a crearne una copia.

Fatto tutto questo aggiungiamo un metodo per la stampa della matrice:

def stampa():
    for r in mtrx:
        for c in r:
            print(c,end="")
        print()

def stampa():

for r in mtrx:

for c in r:

print(c,end="")

print()

E un metodo per prendere uno dei percorsi più corti calcolati (ricordiamoci che potrebbero esserci più percorsi):

def elabora():
    for p in percorsi:
        if len(p) == minlen:
            for c in p:
                if c != pi and c != pf:
                   mtrx[c[0]][c[1]] = "o"
            print(p)
            break

def elabora():

for p in percorsi:

if len(p) == minlen:

for c in p:

if c != pi and c != pf:

mtrx[c[0]][c[1]] = "o"

print(p)

break

Infine uniamo tutto quanto insieme, importando anche la libreria temporale con import time per valutare la velocità di elaborazione.

ti = time.time()

blocchi()
inizio()

print("mappa senza percorso")
stampa()

trova(pi,[])

print("mappa con percorso")
elabora()
stampa()
print("percorsi trovati %d" % len(percorsi))

tf = time.time()

print("tempo di calcolo: %.2f s" % (tf - ti))

ti = time.time()

blocchi()

inizio()

print("mappa senza percorso")

stampa()

trova(pi,[])

print("mappa con percorso")

elabora()

stampa()

print("percorsi trovati %d" % len(percorsi))

tf = time.time()

print("tempo di calcolo: %.2f s" % (tf - ti))

Di seguito il codice completo:

import random
import time

n = 10 # numero di colonne
m = 10 # numero di righe
x = 10 # numero di ostacoli
pi = [] # punto di partenza
pf = [] # punto di arrivo
percorsi = [] # tutti i percorsi possibili
minlen = 0 # lunghezza trovata

mtrx = [["-" for c in range(m)] for r in range(n)]

def blocchi():
    t = 0
    while t < x:
        tc = random.randint(0, m-1)
        tr = random.randint(0, n-1)
        if mtrx[tr][tc] != "X":
            mtrx[tr][tc] = "X"
            t += 1

def inizio():
    global pi, pf
    t = 0
    while t < 2:
        tc = random.randint(0, m-1)
        tr = random.randint(0, n-1)
        if mtrx[tr][tc] == "-":
            if t == 0:
                mtrx[tr][tc] = "A"
                pi = [tr,tc]
            else:
                mtrx[tr][tc] = "B"
                pf = [tr,tc]
            t += 1

def stampa():
    for r in mtrx:
        for c in r:
            print(c,end="")
        print()

def trova(si,percorso=[]):
    # usiamo minlen come variabile globale
    global minlen
    # se la posizione corrente rientra nella matrice, allora procediamo
    if si[0] >= 0 and si[0] < n and si[1] >= 0 and si[1] < m:
        # se la posizione non e' occupata da un blocco e non e' gia' presente nel percorso procediamo
        if mtrx[si[0]][si[1]] != "X" and si not in percorso:
            # aggiungiamo la posizione
            percorso.append(si)
            # se il percorso supera la minima lunghezza trovata e tale lunghezza e' maggiore di 0, interrompiamo la ricorsione
            if len(percorso) > minlen and minlen > 0: return
            # se la posizione e' occupata dalla B allora abbiamo trovato la fine
            if mtrx[si[0]][si[1]] == "B":
                # se la lunghezza del percorso trovato e' minore della minore trovata
                # fino a quel momento, oppure la minore lunghezza e' a 0, aggiorniamo la lunghezza minore
                if len(percorso) < minlen or minlen == 0: minlen = len(percorso)
                #aggiungiamo il percorso ai percorsi trovati
                percorsi.append([]+percorso)
            #altrimenti eseguiamo la funzione sulle caselle circostanti
            else:
                trova([si[0]-1,si[1]],[]+percorso)
                trova([si[0]+1,si[1]],[]+percorso)
                trova([si[0],si[1]-1],[]+percorso)
                trova([si[0],si[1]+1],[]+percorso)

def elabora():
    for p in percorsi:
        if len(p) == minlen:
            for c in p:
                if c != pi and c != pf:
                   mtrx[c[0]][c[1]] = "o"
            print(p)
            break
    
ti = time.time()

blocchi()
inizio()

print("mappa senza percorso")
stampa()

trova(pi,[])

print("mappa con percorso")
elabora()
stampa()
print("percorsi trovati %d" % len(percorsi))

tf = time.time()

print("tempo di calcolo: %.2f s" % (tf - ti))

import random

import time

n = 10 # numero di colonne

m = 10 # numero di righe

x = 10 # numero di ostacoli

pi = [] # punto di partenza

pf = [] # punto di arrivo

percorsi = [] # tutti i percorsi possibili

minlen = 0 # lunghezza trovata

mtrx = [["-" for c in range(m)] for r in range(n)]

def blocchi():

t = 0

while t < x:

tc = random.randint(0, m-1)

tr = random.randint(0, n-1)

if mtrx[tr][tc] != "X":

mtrx[tr][tc] = "X"

t += 1

def inizio():

global pi, pf

t = 0

while t < 2:

tc = random.randint(0, m-1)

tr = random.randint(0, n-1)

if mtrx[tr][tc] == "-":

if t == 0:

mtrx[tr][tc] = "A"

pi = [tr,tc]

else:

mtrx[tr][tc] = "B"

pf = [tr,tc]

t += 1

def stampa():

for r in mtrx:

for c in r:

print(c,end="")

print()

def trova(si,percorso=[]):

# usiamo minlen come variabile globale

global minlen

# se la posizione corrente rientra nella matrice, allora procediamo

if si[0] >= 0 and si[0] < n and si[1] >= 0 and si[1] < m:

# se la posizione non e' occupata da un blocco e non e' gia' presente nel percorso procediamo

if mtrx[si[0]][si[1]] != "X" and si not in percorso:

# aggiungiamo la posizione

percorso.append(si)

# se il percorso supera la minima lunghezza trovata e tale lunghezza e' maggiore di 0, interrompiamo la ricorsione

if len(percorso) > minlen and minlen > 0: return

# se la posizione e' occupata dalla B allora abbiamo trovato la fine

if mtrx[si[0]][si[1]] == "B":

# se la lunghezza del percorso trovato e' minore della minore trovata

# fino a quel momento, oppure la minore lunghezza e' a 0, aggiorniamo la lunghezza minore

if len(percorso) < minlen or minlen == 0: minlen = len(percorso)

#aggiungiamo il percorso ai percorsi trovati

percorsi.append([]+percorso)

#altrimenti eseguiamo la funzione sulle caselle circostanti

else:

trova([si[0]-1,si[1]],[]+percorso)

trova([si[0]+1,si[1]],[]+percorso)

trova([si[0],si[1]-1],[]+percorso)

trova([si[0],si[1]+1],[]+percorso)

def elabora():

for p in percorsi:

if len(p) == minlen:

for c in p:

if c != pi and c != pf:

mtrx[c[0]][c[1]] = "o"

print(p)

break

ti = time.time()

blocchi()

inizio()

print("mappa senza percorso")

stampa()

trova(pi,[])

print("mappa con percorso")

elabora()

stampa()

print("percorsi trovati %d" % len(percorsi))

tf = time.time()

print("tempo di calcolo: %.2f s" % (tf - ti))

L’output finale darà qualcosa di simile a questo:

Vedi articolo

22 Febbraio 2020 Nessun commento

[python] Calcolare le soluzioni di un sistema lineare di primo grado utilizzando il metodo di Cramer (senza librerie aggiuntive)

Obiettivo: Vogliamo calcolare, utilizzando Python, tutte le soluzioni per un sistema lineare di primo grado utilizzando le matrici e il metodo di Cramer. Per farlo non utilizzeremo librerie aggiuntive, se non quanto disponibile nativamente dentro Python.

Ovviamente lo scopo dell’esercizio è l’utilizzo di Python, visto che si potrebbe risolvere agilmente con librerie come SciPy e NumPy.

Supponiamo di avere un sistema lineare come quello seguente (l’ho scopiazzato spudoratamente da YouMath, dove c’è anche un’esaustiva spiegazione sul metodo di Cramer):

$\begin{cases}2x+y+z=1 \\ 4x-y+z=-5 \\ -x+y+2z=5 \end{cases}$

La matrice associata ai coefficienti ed il relativo determinante sarebbe questo:

$\mbox{D}=\left| \begin{matrix} 2 & 1 & 1 \\ 4 & -1 & 1 \\ -1 & 1 & 2 \end{matrix}\right|=-12$

Mentre la matrice dei termini noti sarebbe:

$\mbox{A}=\left| \begin{matrix} 1 \\ -5 \\ 5 \end{matrix}\right|$

Giusto per curiosità la soluzione immediata con NumPy sarebbe la seguente:

import numpy as np

a = np.array([[2,1,1],[4,-1,1],[-1,1,2]])
b = np.array([1,-5,5])
x = np.linalg.solve(a, b)
print x

import numpy as np

a = np.array([[2,1,1],[4,-1,1],[-1,1,2]])

b = np.array([1,-5,5])

x = np.linalg.solve(a, b)

print x

Il risultato nel caso specifico darà: [-1. 2. 1.]

Noi vogliamo costruire qualcosa di simile in Python 2.7.

Cominciamo creando la base della nostra classe perché possa accettare i medesimi argomenti:

class SistemaLineare():

    __coeff = []
    __tnoti = []
    
    def __init__(s,coeff,tnoti):
        
        s.__coeff = coeff
        s.__tnoti = tnoti

    def solve(s):
        return []


sl = SistemaLineare([[2,1,1],[4,-1,1],[-1,1,2]],[1,-5,5])
x = sl.solve()
print x

class SistemaLineare():

__coeff = []

__tnoti = []

def __init__(s,coeff,tnoti):

s.__coeff = coeff

s.__tnoti = tnoti

def solve(s):

return []

sl = SistemaLineare([[2,1,1],[4,-1,1],[-1,1,2]],[1,-5,5])

x = sl.solve()

print x

Fatto questo cominciamo a creare i metodi di cui avremo bisogno. Il metodo di Creamer con il calcolo del determinante implica, per matrici di dimensione superiore a 2×2, che si debba poter ridurre la matrice in sottomatrici.

Giusto per chiarezza, nel caso del determinante D della suddetta matrice, il calcolo si svolgerebbe in questo modo:

$\mbox{D}=\left| \begin{matrix} 2 & 1 & 1 \\ 4 & -1 & 1 \\ -1 & 1 & 2 \end{matrix}\right|= 2 * \left| \begin{matrix} -1 & 1 \\ 1 & 2 \end{matrix}\right| - 1 * \left| \begin{matrix} 4 & 1 \\ -1 & 2 \end{matrix}\right| + 1 * \left| \begin{matrix} 4 & -1 \\ -1 & 1\end{matrix}\right| =\newline = 2*(-1*2-1*1)-1*(4*2-(-1)*1)+1*(4*1-(-1)*(-1)) = \newline = 2*(-3)-1*(9)+1*(3)=\newline =-6-9+3=-12$

Ogni sottomatrice prende tutti i valori della matrice corrente eccetto quelli nella riga e nella colonna della posizione attuale. Scriviamo quindi la nostra funzione nella maniera seguente:

    def __subMatrice(s,r,c,matrice):
        nuova = []
        nr = len(matrice)
        nc = len(matrice[0])
        for i in range(nr):
            if i == r: continue
            riga = []
            for j in range(nc):
                if j == c: continue
                riga.append(matrice[i][j])
            nuova.append(riga)
        return nuova

def __subMatrice(s,r,c,matrice):

nuova = []

nr = len(matrice)

nc = len(matrice[0])

for i in range(nr):

if i == r: continue

riga = []

for j in range(nc):

if j == c: continue

riga.append(matrice[i][j])

nuova.append(riga)

return nuova

Per calcolare il determinante vogliamo fare due operazioni distinte: il calcolo per matrici 2×2 e il calcolo per riduzione delle matrici di dimensione superiore. Iniziamo scrivendo l’operazione per quelle 2×2:

    def __determ2x2(s,matrice):
        return matrice[0][0]*matrice[1][1]-matrice[0][1]*matrice[1][0]

1 2	def __determ2x2(s,matrice): return matrice[0][0]matrice[1][1]-matrice[0][1]matrice[1][0]

Per calcolare gli altri determinanti procederemo invece con:

    def __determ(s,matrice):
        nr = len(matrice)
        nc = len(matrice[0])
        if nr == 2 and nc == 2:
            return s.__determ2x2(matrice)
        else:
            risultato = 0
            for c in range(nc):
                risultato += (1-2*(c%2))*matrice[0][c]*s.__determ(s.__subMatrice(0,c,matrice))
            return risultato

def __determ(s,matrice):

nr = len(matrice)

nc = len(matrice[0])

if nr == 2 and nc == 2:

return s.__determ2x2(matrice)

else:

risultato = 0

for c in range(nc):

risultato += (1-2*(c%2))*matrice[0][c]*s.__determ(s.__subMatrice(0,c,matrice))

return risultato

In particolare con (1-2*(c%2)) calcoliamo il segno per ogni elemento della prima riga. In particolare ricordiamo che gli elementi saranno calcolati in ordine da 0, 1, 2, 3, 4 ecc. Se calcoliamo il resto per ognuno di essi avremo 0, 1, 0, 1, 0 ecc. Eseguendo la suddetta operazione avremo quindi 1-0, 1-2, 1-0, 1-2, 1-0 ecc. Questo ci darà i segni come 1, -1, 1, -1, 1 ecc.

A questo punto ci manca solo un metodo che ci permetta di creare nuove matrici per calcolare i vari determinanti per x, y, z ecc. Ricordiamoci che i vari risultati saranno dati da:

$x=\frac{\mbox{D}_x}{\mbox{D}}=\frac{12}{-12}=-1\\ \\ \\ y=\frac{\mbox{D}_y}{\mbox{D}}=\frac{-24}{-12}=2\\ \\ \\ z=\frac{\mbox{D}_z}{\mbox{D}}=\frac{-12}{-12}=1$

Dobbiamo fare attenzione ad un dettaglio importante. In Python le liste vengono passate per riferimento, questo vuol dire che modificando ogni lista “copiata” si modifica in realtà la lista originale all’indirizzo di memoria. Per copiare una matrice multidimensionale è necessario quindi copiare i singoli valori nella nuova matrice, nella maniera seguente darebbe errore:

tmp = [c for c in [r for r in matrice]]

1	tmp = [c for c in [r for r in matrice]]

Quindi procediamo in questo modo:

        nr = len(matrice)
        nc = len(matrice[0])
        tmp = []
        for i in range(nr):
            tmp.append([])
            for j in range(nc):
                tmp[i].append(matrice[i][j])

nr = len(matrice)

nc = len(matrice[0])

tmp = []

for i in range(nr):

tmp.append([])

for j in range(nc):

tmp[i].append(matrice[i][j])

La nostra funzione di sostituzione sostituirà quindi i termini noti nella colonna preselezionata.

    def __sostitMatr(matrice,tnoti,c):
        nr = len(matrice)
        tmp = [c for c in [r for r in matrice]]
        for r in range(nr):
            tmp[r][c] = tnoti[r]
        return tmp

def __sostitMatr(matrice,tnoti,c):

nr = len(matrice)

tmp = [c for c in [r for r in matrice]]

for r in range(nr):

tmp[r][c] = tnoti[r]

return tmp

A questo punto possiamo scrivere il metodo che calcolerà la soluzione, alla maniera seguente:

    def __soluzione(s,matrice,tnoti):
        nc = len(matrice[0])
        d = s.__determ(matrice)
        if d != 0:
            x = []
            for c in range(nc):
                dx = s.__determ(s.__sostitMatr(matrice,tnoti,c))
                x.append(1.0*dx/d)
            return x
        else:
            return []

def __soluzione(s,matrice,tnoti):

nc = len(matrice[0])

d = s.__determ(matrice)

if d != 0:

x = []

for c in range(nc):

dx = s.__determ(s.__sostitMatr(matrice,tnoti,c))

x.append(1.0*dx/d)

return x