Algoritmi genetici

# DEAP_generico.py
#
# esempio di utilizzo della libreria per la computazione genetica evolutiva
# dei problemi denominata DEAP.
# in questo caso ho utilizzato lo scheletro della risoluzione di un
# problema generico per risolvere il problema di ottimizzazione
# noto come Knapsack Problem.
# documentazione su : https://deap.readthedocs.io/en/master/index.html
#
# by Andrea Bianchini (2021)



import random

from deap import base
from deap import creator
from deap import tools

IND_SIZE = 50
C = 10000
MIN_WEIGHT = int(C*0.01)
MAX_WEIGHT = int(C*0.07)
MAX=0
sol=[]
items=[random.randint(MIN_WEIGHT,MAX_WEIGHT) for _ in range(IND_SIZE)]

creator.create("FitnessMax", base.Fitness, weights=(1.0,))
creator.create("Individual", list, fitness=creator.FitnessMax)

toolbox = base.Toolbox()
# Attribute generator 
toolbox.register("attr_bool", random.randint, 0, 1)
# Structure initializers
toolbox.register("individual", tools.initRepeat, creator.Individual, 
    toolbox.attr_bool, IND_SIZE)
toolbox.register("population", tools.initRepeat, list, toolbox.individual)

def evalOneMax(individual):
    global sol
    global MAX
    e1 = sum([items[i]*individual[i] for i in range(len(individual))])
    if e1>MAX and e1<=C:
        MAX = e1
        sol=individual
    return e1,

toolbox.register("evaluate", evalOneMax)
toolbox.register("mate", tools.cxTwoPoint)
toolbox.register("mutate", tools.mutFlipBit, indpb=0.05)
toolbox.register("select", tools.selTournament, tournsize=3)

summa=0
def main():
    global summa
    pop = toolbox.population(n=300)

    # Evaluate the entire population
    fitnesses = list(map(toolbox.evaluate, pop))
    for ind, fit in zip(pop, fitnesses):
        ind.fitness.values = fit

    # CXPB  is the probability with which two individuals
    #       are crossed
    #
    # MUTPB is the probability for mutating an individual
    CXPB, MUTPB = 0.5, 0.2

    # Extracting all the fitnesses of 
    fits = [ind.fitness.values[0] for ind in pop]

    # Variable keeping track of the number of generations
    g = 0
    
    # Begin the evolution
    
    while max(fits) < C and g < 1000:
        # A new generation
        g = g + 1
        print("-- Generation %i --" % g)

        # Select the next generation individuals
        offspring = toolbox.select(pop, len(pop))
        # Clone the selected individuals
        offspring = list(map(toolbox.clone, offspring))

        # Apply crossover and mutation on the offspring
        for child1, child2 in zip(offspring[::2], offspring[1::2]):
            if random.random() < CXPB:
                toolbox.mate(child1, child2)
                del child1.fitness.values
                del child2.fitness.values

        for mutant in offspring:
            if random.random() < MUTPB:
                toolbox.mutate(mutant)
                del mutant.fitness.values

        # Evaluate the individuals with an invalid fitness
        invalid_ind = [ind for ind in offspring if not ind.fitness.valid]
        fitnesses = map(toolbox.evaluate, invalid_ind)
        for ind, fit in zip(invalid_ind, fitnesses):
            ind.fitness.values = fit

        pop[:] = offspring

        # Gather all the fitnesses in one list and print the stats
        fits = [ind.fitness.values[0] for ind in pop]
        
        length = len(pop)
        mean = sum(fits) / length
        sum2 = sum(x*x for x in fits)
        std = abs(sum2 / length - mean**2)**0.5
        
        print("  Min %s" % min(fits))
        print("  Max %s" % max(fits))
        print("  Avg %s" % mean)
        print("  Std %s" % std)

        if max(fits) <=C and summa<max(fits):
            summa = max(fits)

main()
print()
print("Soluzione ottima = %d" %MAX)
print("Lista items completa :")
print(items)
print("Lista items soluzione :")
osol = [items[i]*sol[i] for i in range(IND_SIZE)]
print(osol)

Esempio:

Soluzione ottima = 10000
Lista items completa :
[481, 167, 361, 111, 670, 602, 119, 331, 654, 155, 400, 227, 651, 531, 413, 134, 409, 140, 488, 457, 495, 628, 153, 632, 327, 159, 593, 633, 682, 392, 368, 526, 599, 478, 408, 315, 466, 582, 302, 172, 427, 173, 551, 673, 272, 158, 502, 269, 685, 588]
Lista items soluzione :
[0, 0, 361, 0, 670, 0, 0, 331, 654, 0, 0, 0, 651, 0, 0, 0, 409, 140, 488, 0, 0, 628, 0, 632, 327, 0, 593, 0, 682, 0, 368, 0, 0, 478, 0, 315, 0, 582, 0, 172, 427, 0, 551, 0, 272, 0, 0, 269, 0, 0]
>>> 

Valore atteso, varianza e deviazione standard

# varianza.py
#
# questo programma calcola il valore medio, la varianza
# e la deviazione standard di una lista di numeri
# interi generati casualmente.
#
# by Andrea Bianchini (2021)
#


from random import randint
import math

N = 20
MIN = 0
MAX = 1000

s = [randint(MIN,MAX) for _ in range(N)]

print("La lista generata è la seguente :")
print(s)

# Calcolo valore medio
vm=float(sum(s))
vm=vm/N

# Calcolo varianza
scarti = [(sx-vm)*(sx-vm) for sx in s]
vms = float(sum(scarti))
vms = vms/N

print()
print("Scarti quadratici lista originale : ")
print(scarti)
print()
print("Valore medio lista originale: %.2f" %vm)
print()
print("Varianza lista originale: %.2f" %vms)
print()
print("Deviazione standard lista originale: %.2f" %(math.sqrt(vms)))
print()
print("Deviazione minima lista originale: %.2f " %(math.sqrt(min(scarti))))
print()
print("Deviazione massima lista originale: %.2f " %(math.sqrt(max(scarti))))

Esempio:

La lista generata è la seguente :
[73, 801, 284, 79, 291, 425, 429, 265, 494, 330, 376, 521, 333, 162, 763, 202, 66, 462, 202, 366]

Scarti quadratici lista originale : 
[74638.23999999999, 206843.04, 3868.839999999999, 71395.84, 3047.0399999999986, 6209.440000000001, 6855.840000000002, 6593.439999999998, 21844.840000000004, 262.43999999999966, 888.0400000000006, 30555.040000000005, 174.2399999999997, 33929.64, 173722.24000000002, 20793.639999999996, 78512.04, 13409.640000000003, 20793.639999999996, 392.0400000000005]

Valore medio lista originale: 346.20

Varianza lista originale: 38736.46

Deviazione standard lista originale: 196.82

Deviazione minima lista originale: 13.20 

Deviazione massima lista originale: 454.80 
>>> 

Programmazione Lineare

# pulp1.py
#
# Risoluzione di un problema di programmazione lineare
# tramite la libreria PuLP.
#
# definizione problema by https://www3.diism.unisi.it/~agnetis/esesvolti.pdf
# soluzione in Python tramite utilizzo libreria PuLP, by Andrea Bianchini 2021
#
# Problema:
# Un lanificio produce filato di tipo standard e di tipo speciale
# utilizzando 3 diverse macchine, le cui produzioni orarie sono le seguenti:
# macchina A: 3 matasse standard e 1 speciale
# macchina B: 2 matasse standard e 2 speciali
# macchina C: 2 matasse standard e 1 speciale
# Il mercato richiede almeno 60 matasse standard e 40 di tipo speciale al giorno. I costi
# orari delle due macchine sono: 90 euro per la A, 80 euro per B, 60 euro per C.
# Scrivere un modello di programmazione lineare per determinare la produzione giornaliera
# di costo minimo. (Non occorre imporre il vincolo che le ore giornaliere non superino 24)
#


from pulp import *

a = pulp.LpVariable("a", lowBound=0)
b = pulp.LpVariable("b", lowBound=0)
c = pulp.LpVariable("c", lowBound=0)

problem = pulp.LpProblem("Un semplice problema di min", LpMinimize)

problem += 90*a + 80*b + 60*c, "The objective function"
problem += 3*a + 2*b + 2*c >= 60, "1st constraint"
problem += a + 2*b + c >= 40, "2nd constraint"
problem += a >= 0, "3rd constraint"
problem.solve()

print("Risultati della ottimizzazione:")
for variable in problem.variables():
    print(variable.name + "=" + str(variable.varValue))
print("Costo minimo netto totale: %.1f" %value(problem.objective))

Esempio:

Risultati della ottimizzazione:
a=0.0
b=10.0
c=20.0
Costo minimo netto totale: 2000.0
>>> 

MinMax

# minmax.py
#
# trova il minimo ed il massimo elemento di una lista di interi
# senza utilizzare le funzioni min e max.
#
# by Andrea Bianchini, 2021
#

nums = [30,11,54,78,12,5,63,20,43,26,52]

print("Lista originale:")
print(nums)

print()
print("Lista ordinata :")
nums.sort()
print(nums)

print()
print("Il numero più piccolo è %d" %nums[0])
print("Il numero più grande è %d" %nums[len(nums)-1])

Esempio:

Lista originale:
[30, 11, 54, 78, 12, 5, 63, 20, 43, 26, 52]

Lista ordinata :
[5, 11, 12, 20, 26, 30, 43, 52, 54, 63, 78]

Il numero più piccolo è 5
Il numero più grande è 78
>>> 

Generatore di Password

# GenPassword.py - generatore di password
# Legge dall'input la lunghezza della password desiderata e la probabilità
# della presenza di caratteri speciali espressa come intero tra 0 e 10.
# Fornisce in output la password
#
# by Andrea Bianchini 2021
#

from random import randint

s = "0123456789abcdefghijklmnopqrstuvxyzABCDEFGHIJKLMNOPQRSTUVXYZ"
sp = "_#:.,;^&%@"

l = int(input("Lunghezza password in caratteri : "))
ps = int(input("Probabilità caratteri speciali (0-10) : "))

pw=""
for i in range(l):
    ln = l * ps/10
    lx = randint(0,l)
    if ps!=0 and lx<=ln:
        pw = pw + sp[randint(0,len(sp)-1)]
    else:
        pw = pw + s[randint(0,len(s)-1)]

print("La password generata è : "+pw)

Esempio:

Lunghezza password in caratteri : 10
Probabilità caratteri speciali (0-10) : 2
La password generata è : A%@Ik.jtm7
>>> 

Piccolo Sistema Esperto

# by Andrea Bianchini 2021
# questa è la base di conoscenza del Sistema Esperto

kb=[["C'è alimentazione di rete in casa ?",1,4],
["Con una lampadina sana si accende ?",2,3],
["La lampadina è fulminata; sostituiscila",-1,-1],
["C'è un problema elettrico o nella spina o nel portalampade",-1,-1],
["Collega la rete; (salvavita o interruttore generale)",-1,-1]]
# by Andrea Bianchini 2021
# questo è il motore inferenziale del sistema esperto

import kb

print("Sistema esperto per risoluzione problema : non si accende lampadina")
print("-------------------------------------------------------------------")
print()

k=0
while k!=-1:
    if k>-1:
        r=input(kb.kb[k][0]+"([s]/n): ")
        if r.upper()=="S" or r=="":
            k=kb.kb[k][1]
        else:        
            k=kb.kb[k][2]

print("fine")

Esempio:

Sistema esperto per risoluzione problema : non si accende lampadina
-------------------------------------------------------------------

C'è alimentazione di rete in casa ?([s]/n): s
Con una lampadina sana si accende ?([s]/n): n
C'è un problema elettrico o nella spina o nel portalampade([s]/n): 
fine
>>> 

Questo è un esempio di Sistema Esperto. La base della conoscenza è volutamente molto semplice. Anche il motore inferenziale è abbastanza semplice ma con questo modello potete costruire un Sistema Esperto veramente capace.

Successione di Fibonacci

def fibonacci(k):
    if k == 0:
        return 0;
    if k == 1:
        return 1;
    if k>1 :
        return fibonacci(k-1)+fibonacci(k-2)

n = int(input("Quanti numeri di fibonacci vuoi stampare ? : "))
for i in range(1,n+1):
    print(fibonacci(i))

Esempio:

Quanti numeri di fibonacci vuoi stampare ? : 10
1
1
2
3
5
8
13
21
34
55

La successione di Fibonacci pare comparire in molti campi scientifici ed in natura, per citarne alcuni, nella musica, nell’arte, nell’informatica. Viene anche chiamata successione naturale.

Di seguito il link ad una trattazione dell’argomento su wikipedia :

https://it.wikipedia.org/wiki/Successione_di_Fibonacci

The intangibilis

The Intangibilis by Andrea Bianchini

…………….

The intangibilis

Sempre più spesso nei bilanci economici delle aziende italiane vediamo comparire ultimamente la voce beni intangibili.
Tra questi beni sono classificati i capitali intellettuali, i quali hanno sempre avuto un ruolo determinante per il successo delle aziende, ma sono di difficile quantificazione.
In prima approssimazione il capitale intellettuale di una azienda può essere suddiviso in tre categorie:
1-Capacità relazionali.
2-Capitale umano.
3-Capacità organizzativa.
E’ evidente come la mancanza di una di queste tre componenti porterebbe al fallimento dell’azienda, ma è difficilissimo quantificare con precisione l’apporto in termini economici del valore di ciascuna di queste componenti, il che, è una grave lacuna. Infatti se la nostra azienda andasse male o non riuscisse a decollare o nella peggiore delle ipotesi, fallisse, rischieremmo di non comprenderne il motivo.
Esistono dei libri di recente edizione che trattano questi argomenti.
Per concludere citerei la frase coniata da Albert Einstein:
“Non tutto ciò che conta può essere contato, e non tutto ciò che può essere contato conta”.

…………….

The intangibilis

More and more often in the financial statements of Italian companies we see the item intangible assets appear lately.
Intellectual capital is classified among these assets, which have always played a decisive role in the success of companies, but are difficult to quantify.
As a first approximation, the intellectual capital of a company can be divided into three categories:
1-Relational skills.
2-Human capital.
3-Organizational capacity.
It is clear that the lack of one of these three components would lead to the bankruptcy of the company, but it is very difficult to accurately quantify the contribution in economic terms of the value of each of these components, which is a serious shortcoming. In fact, if our company goes badly or fails to take off or, at worst, fails, we risk not understanding why.
There are recently published books that deal with these topics.
To conclude, I would quote the phrase coined by Albert Einstein:
“Not everything that matters can be counted, and not everything that can be counted counts”.

by Andrea Bianchini

Leva finanziaria


capitale = int(input("Capitale complessivo detenuto (euro) : "))
passivita = int(input("Totale passività (euro) : "))

if capitale<1.0:
    capitale=1.0
leva = (capitale+passivita)/capitale

print("La tua leva finanziaria è pari a {:.2f}".format(leva))

print("")
print("Legenda:")
print("leva = 1 -> non hai passività (tutto capitale)")
print("leva tra 1 e 2 -> le tue passività non superano il tuo capitale")
print("leva > 2 -> attenzione ! più è alta la leva, più è alto il tuo rischio!")

Nella mia città si dice : ‘chi non risica non rosica’.

Infatti una leva leggermente superiore a 2, che indica sovraindebitamento, può essere stimolante per la crescita per via di effetti compensativi del fisco.

Esempio:

Capitale complessivo detenuto (euro) : 1000
Totale passività (euro) : 2000
La tua leva finanziaria è pari a 3.00

Legenda:
leva = 1 -> non hai passività (tutto capitale)
leva tra 1 e 2 -> le tue passività non superano il tuo capitale
leva > 2 -> attenzione ! più è alta la leva, più è alto il tuo rischio!
>>>