Petar Karan

[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:

[word] Rimuovere “Limita modifica” da un file docx di Word

Problema: Il file word risulta protetto con l’opzione Limita modifica che impedisce anche di copiare il testo dal file.

Soluzione: Rinominare il file docx con estensione zip, decomprimere il file, individuare all’interno della cartella il file word/settings.xml, aprirlo con un editor di testo ed impostare su false il parametro w:enforcement, salvare il file, ricomprimere tutto il contenuto della cartella in un file zip e rinominarlo in docx

Vediamo la procedura nel dettaglio.

Anzitutto individuiamo il file Word che non permette le modifiche. Aprendo il file e andando nella scheda Revisione > Proteggi cliccando sull’opzione Limita modifica si aprirà una finestra simile alla seguente:

Il file potrebbe essere protetto a diversi livelli e non consentire nemmeno la copia del testo.

Per rimuovere la protezione procediamo nella maniera seguente.

A questo punto prendiamo il file e rinominiamolo con l’estensione zip.

Per farlo da Windows 10 dobbiamo attivare la visualizzazione delle estensioni dei file. Se non l’abbiamo già fatto, in Esplora Risorse andiamo su Visualizza > Mostra / Nascondi e spuntiamo Estensioni nomi file.

Una volta rinominato il file in formato zip possiamo decomprimerlo in una cartella, trovando dentro una struttura simile a questa:

Entriamo nella cartella word e individuiamo il file settings.xml

Apriamo il file con un editor di testo (consiglio Notepad++) e individuiamo il parametro w:enforcement

Il parametro sarà probabilmente impostato su true oppure 1.

Modifichiamolo su false.

A questo punto torniamo nella cartella precedente e comprimiamo tutti i file.

Otterremo un nuovo file zip, cambiamo di nuovo l’estensione in docx e il gioco è fatto.

[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)

[plesk] Aggiungere manualmente IP alla blacklist di fail2ban

In Plesk purtroppo non è possibile, tramite l’interfaccia grafica, aggiungere manualmente IP alla blacklist di fail2ban.

Lo si può fare esclusivamente, al momento attuale, tramite terminale, interagendo direttamente con fail2ban.

Per bloccare manualmente un IP con fail2ban si può utilizzare il seguente comando:

fail2ban-client set nome-jail banip xx.xx.xx.xx

1	fail2ban-client set nome-jail banip xx.xx.xx.xx

Dove al posto di nome-jail si inserirà una delle jail configurate su fail2ban e al posto di xx.xx.xx.xx l’indirizzo IP che si intende bloccare.

[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:

[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.

[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.

[HOI4] Evitare che l’Albania venga annessa dall’Italia automaticamente se si trova in una fazione in Hearts of Iron 4 [BUG risolto]

In Hearts of Iron 4, attorno agli inizi di aprile del 1939 (storicamente il 7 aprile 1939) l’Italia completa il focus Albanian Occupation, al quale segue l’ultimatum italiano all’Albania e la conseguente occupazione. Al giocatore umano compare un messaggio come il seguente, e può scegliere se arrendersi oppure resistere. In caso di resistenza l’Italia dichiara immediatamente guerra.

Il problema sorge quando a giocare l’Albania è l’IA, che si arrende sempre, in tutte le circostanze, anche quando sarebbe avvantaggiata. Questo succede per esempio quando l’Albania si trova con un governo comunista ed è alleata del Comintern oppure fa parte dell’Alleanza Balcanica dei Lavoratori (guidata dalla Jugoslavia comunista), anche se un altro stato la sta proteggendo.

Il problema sta nel trigger degli eventi che seguono al focus tree dell’Italia. Per analizzare il bug individuiamo la cartella /events nella radice di HOI4 (nel mio caso avendo il gioco su Steam il percorso completo è \Steam\steamapps\common\Hearts of Iron IV\events\) e apriamo il file Italy.txt. Le righe di codice che ci interessano sono dalla 51 alla 159.

# Albania Receives Ultimatum
country_event = {
	id = italy.3
	title = italy.3.t
	desc = italy.3.d
	picture = GFX_report_event_albanian_king_zog
	
	is_triggered_only = yes
	
	option = { # Yield
		name = italy.3.a
		ai_chance = {
			base = 40
			modifier = {
				factor = 0
				OR = {			
					any_other_country = {
						OR = {
							is_major = yes
							tag = YUG
						}
						NOT = { tag = ITA }
						OR = {
							has_guaranteed = ROOT
							is_in_faction_with = ROOT
						}
					}
					AND = {
						is_subject = yes
						NOT = { is_subject_of = ITA }
					}
				}
			}
			modifier = {
				factor = 0.5
				OR = {
					has_government = communism
					has_government = fascism #glorious Albania will never yield!
				}
			}
			modifier = {
				factor = 5
				is_subject_of = ITA
			}
		}
		ITA = {
			country_event = { days = 1 id = italy.1 }
		}
		custom_effect_tooltip = GAME_OVER_TT
	}
	option = { # Resist
		name = italy.3.b
		ai_chance = {
			factor = 20 
			modifier = {
				factor = 0
				OR = {
					AND = {
						is_in_faction_with = ITA
						ITA = { is_faction_leader = yes }
					}
					AND = {
						any_other_country = {
							OR = {
								is_major = yes
								tag = YUG
							}
							NOT = { tag = ITA }
							OR = {
								has_guaranteed = ROOT
								is_in_faction_with = ROOT
							}
						}
						is_historical_focus_on = yes
					}
					AND = {
						is_in_faction = no 
						NOT = {
							any_other_country = {
								NOT = { tag = ITA }
								has_guaranteed = ROOT
							} 
						}
					}
				}
			}
			modifier = {
				add = 100
				is_in_faction = yes
				NOT = { is_in_faction_with = ITA }
			}
			modifier = {
				add = 100
				is_subject = yes
				NOT = { is_subject_of = ITA }
			}
		}
		ITA = {
			effect_tooltip = {
				create_wargoal = {
					type = take_state_focus
					target = ALB
					generator = { 44 }
				}
			}
			country_event = { days = 1 id = italy.2 }
		}
	}
}

100

101

102

103

104

105

106

107

108

109

# Albania Receives Ultimatum

country_event = {

id = italy.3

title = italy.3.t

desc = italy.3.d

picture = GFX_report_event_albanian_king_zog

is_triggered_only = yes

option = { # Yield

name = italy.3.a

ai_chance = {

base = 40

modifier = {

factor = 0

OR = {

any_other_country = {

OR = {

is_major = yes

tag = YUG

}

NOT = { tag = ITA }

OR = {

has_guaranteed = ROOT

is_in_faction_with = ROOT

}

AND = {

is_subject = yes

NOT = { is_subject_of = ITA }

}

modifier = {

factor = 0.5

OR = {

has_government = communism

has_government = fascism #glorious Albania will never yield!

}

modifier = {

factor = 5

is_subject_of = ITA

}

ITA = {

country_event = { days = 1 id = italy.1 }

}

custom_effect_tooltip = GAME_OVER_TT

}

option = { # Resist

name = italy.3.b

ai_chance = {

factor = 20

modifier = {

factor = 0

OR = {

AND = {

is_in_faction_with = ITA

ITA = { is_faction_leader = yes }

}

AND = {

any_other_country = {

OR = {

is_major = yes

tag = YUG

}

NOT = { tag = ITA }

OR = {

has_guaranteed = ROOT

is_in_faction_with = ROOT

}

is_historical_focus_on = yes

}

AND = {

is_in_faction = no

NOT = {

any_other_country = {

NOT = { tag = ITA }

has_guaranteed = ROOT

}

modifier = {

add = 100

is_in_faction = yes

NOT = { is_in_faction_with = ITA }

}

modifier = {

add = 100

is_subject = yes

NOT = { is_subject_of = ITA }

}

ITA = {

effect_tooltip = {

create_wargoal = {

type = take_state_focus

target = ALB

generator = { 44 }

}

country_event = { days = 1 id = italy.2 }

}

L’errore si trova esattamente alla riga 104. Le chance perché l’IA decida per la resistenza sono calcolate nel modo seguente:

fattore base per la probabilità impostato a 20
Il primo modificatore moltiplica tale fattore per 0 (qui c’è l’errore) nel caso in cui accada una delle seguenti condizioni:
1. l’Albania è in fazione con l’Italia e il leader è l’Italia
2. Qualunque altro paese sia principale (major) oppure sia la Jugoslavia, non sia l’Italia, e stia garantendo oppure sia in fazione con l’Albania, assieme ai focus storici attivi
3. Non sia in fazione, nessun altra nazione, eccetto dell’Italia, la stia garantendo
Il secondo modificatore aggiunge 100 se l’Albania è in una fazione, che non contenga anche l’Italia
Il terzo aggiunge 100 se l’Albania è controllata o è oggetto di un’altra nazione che non sia l’Italia

Il secondo modificatore dovrebbe aggiungere 100 alla probabilità (rendendola quindi certezza) laddove l’Albania si trovi in una fazione che non contenga l’Italia. Purtroppo però, come è spiegato sulla guida ufficiale, il modifier si comporta come un blocco AND, che moltiplica il risultato totale per il factor e ci aggiunge il valore in add. Purtroppo però vale anche un’altra regola: se il valore intermedio scende a 0 tutte le operazioni successive si fermano e nemmeno gli add possono più modificarlo.

Questo significa che in “Qualunque altro paese sia principale (major) oppure sia la Jugoslavia, non sia l’Italia, e stia garantendo oppure sia in fazione con l’Albania, assieme ai focus storici attivi” per assurdo il fattore viene moltiplicato per 0 e quindi le possibilità che la IA resista sono del 0%. Per correggere il problema è sufficiente rimuovere le seguenti righe di codice:

AND = {
	any_other_country = {
		OR = {
			is_major = yes
			tag = YUG
		}
		NOT = { tag = ITA }
		OR = {
			has_guaranteed = ROOT
			is_in_faction_with = ROOT
		}
	}
	is_historical_focus_on = yes
}

AND = {

any_other_country = {

OR = {

is_major = yes

tag = YUG

}

NOT = { tag = ITA }

OR = {

has_guaranteed = ROOT

is_in_faction_with = ROOT

}

is_historical_focus_on = yes

}

Questo lo possiamo fare creando anche una mod.

Per creare la mod rechiamoci nella cartella C:\Users\<nome-utente>\Documents\Paradox Interactive\Hearts of Iron IV\mod e creiamo un file chiamato CorrezioneAlbania.mod e una cartella chiamata CorrezioneAlbania

Nel file inseriamo le seguenti definizioni (dobbiamo sostanzialmente dare un nome alla mod e scegliere a che cosa si applichi).

version="1"
tags={
	"Events"
}
name="CorrezioneAlbania"
supported_version="1.10.4"
path="C:/Users/<nome-utente>/Documents/Paradox Interactive/Hearts of Iron IV/mod/CorrezioneAlbania"

version="1"

tags={

"Events"

}

name="CorrezioneAlbania"

supported_version="1.10.4"

path="C:/Users/<nome-utente>/Documents/Paradox Interactive/Hearts of Iron IV/mod/CorrezioneAlbania"

Attenzione! Sostituire sempre <nome-utente> con il proprio nome utente nella cartella profilo di Windows.

Nella cartella creare un file chiamato descriptor.mod con al suo interno il seguente codice:

version="1"
tags={
	"Events"
}
name="CorrezioneAlbania"
supported_version="1.10.4"

version="1"

tags={

"Events"

}

name="CorrezioneAlbania"

supported_version="1.10.4"

Creare infine una cartella events nella quale metteremo un file di testo chiamato CorrezioneAlbania.txt. Al suo interno copiamo il codice precedente corretto:

add_namespace = italy

# Albania Receives Ultimatum
country_event = {
	id = italy.3
	title = italy.3.t
	desc = italy.3.d
	picture = GFX_report_event_albanian_king_zog
	
	is_triggered_only = yes
	
	option = { # Yield
		name = italy.3.a
		ai_chance = {
			base = 40
			modifier = {
				factor = 0
				OR = {			
					any_other_country = {
						OR = {
							is_major = yes
							tag = YUG
						}
						NOT = { tag = ITA }
						OR = {
							has_guaranteed = ROOT
							is_in_faction_with = ROOT
						}
					}
					AND = {
						is_subject = yes
						NOT = { is_subject_of = ITA }
					}
				}
			}
			modifier = {
				factor = 0.5
				OR = {
					has_government = communism
					has_government = fascism #glorious Albania will never yield!
				}
			}
			modifier = {
				factor = 5
				is_subject_of = ITA
			}
		}
		ITA = {
			country_event = { days = 1 id = italy.1 }
		}
		custom_effect_tooltip = GAME_OVER_TT
	}
	option = { # Resist
		name = italy.3.b
		ai_chance = {
			factor = 20 
			modifier = {
				factor = 0
				OR = {
					AND = {
						is_in_faction_with = ITA
						ITA = { is_faction_leader = yes }
					}
					AND = {
						is_in_faction = no 
						NOT = {
							any_other_country = {
								NOT = { tag = ITA }
								has_guaranteed = ROOT
							} 
						}
					}
				}
			}
			modifier = {
				add = 100
				is_in_faction = yes
				NOT = { is_in_faction_with = ITA }
			}
			modifier = {
				add = 100
				is_subject = yes
				NOT = { is_subject_of = ITA }
			}
		}
		ITA = {
			effect_tooltip = {
				create_wargoal = {
					type = take_state_focus
					target = ALB
					generator = { 44 }
				}
			}
			country_event = { days = 1 id = italy.2 }
		}
	}
}

add_namespace = italy

# Albania Receives Ultimatum

country_event = {

id = italy.3

title = italy.3.t

desc = italy.3.d

picture = GFX_report_event_albanian_king_zog

is_triggered_only = yes

option = { # Yield

name = italy.3.a

ai_chance = {

base = 40

modifier = {

factor = 0

OR = {

any_other_country = {

OR = {

is_major = yes

tag = YUG

}

NOT = { tag = ITA }

OR = {

has_guaranteed = ROOT

is_in_faction_with = ROOT

}

AND = {

is_subject = yes

NOT = { is_subject_of = ITA }

}

modifier = {

factor = 0.5

OR = {

has_government = communism

has_government = fascism #glorious Albania will never yield!

}

modifier = {

factor = 5

is_subject_of = ITA

}

ITA = {

country_event = { days = 1 id = italy.1 }

}

custom_effect_tooltip = GAME_OVER_TT

}

option = { # Resist

name = italy.3.b

ai_chance = {

factor = 20

modifier = {

factor = 0

OR = {

AND = {

is_in_faction_with = ITA

ITA = { is_faction_leader = yes }

}

AND = {

is_in_faction = no

NOT = {

any_other_country = {

NOT = { tag = ITA }

has_guaranteed = ROOT

}

modifier = {

add = 100

is_in_faction = yes

NOT = { is_in_faction_with = ITA }

}

modifier = {

add = 100

is_subject = yes

NOT = { is_subject_of = ITA }

}

ITA = {

effect_tooltip = {

create_wargoal = {

type = take_state_focus

target = ALB

generator = { 44 }

}

country_event = { days = 1 id = italy.2 }

}

Fatto tutto questo salviamo e avviamo il gioco. Se è andato tutto bene e l’Albania è in fazione con noi, al momento dell’ultimatum dovrebbe rifiutarlo e noi riceveremo la seguente notizia.

In tale caso prepariamoci alla guerra con l’Italia, dal momento che le ultime righe di codice dell’evento la attivano automaticamente:

ITA = {
	effect_tooltip = {
		create_wargoal = {
			type = take_state_focus
			target = ALB
			generator = { 44 }
		}
	}
	country_event = { days = 1 id = italy.2 }
}

ITA = {

effect_tooltip = {

create_wargoal = {

type = take_state_focus

target = ALB

generator = { 44 }

}

country_event = { days = 1 id = italy.2 }

}

Per curiosità, togliendoli questo non avviene. In caso contrario conviene armarsi.

[chrome] Aggirare il blocco del click col tasto destro tramite javascript

Alcuni siti bloccano (senza alcuna vera utilità) l’utilizzo del tasto destro, ossia l’apertura del menù contestuale che, tra le altre cose, permetterebbe di copiare il testo o le immagini.

Questo tipo di blocco può essere aggirato tramite Google Chrome, nel modo seguente:

Premere il tasto F12 mentre si è sulla pagina, aprendo così la console sviluppatore
Aprire la tab della console (qualora non fosse aperta) e digitare document.oncontextmenu=null;
Premere invio

Questo dovrebbe disattivare il blocco del tasto destro e dell’apertura del menù contestuale.

[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