Python – Una breve guida

In questo articolo del Blog AIKnow.info rivedremo brevemente Python, un linguaggio di programmazione molto popolare nelle applicazioni di data science. Il nostro interesse è particolarmente legato al machine learning, dove Python è molto utilizzato come conseguenza della disponibilità di un gran numero di librerie dedicate.

Quindi questo articolo è preparatorio per l’implementazione degli algoritmi di machine learning che vedremo nel seguito.

Python è un linguaggio di alto livello interpretato. L’interprete Python può essere utilizzato per eseguire singole linee di codice semplicemente scrivendole dopo il prompt >>> (Fig.1) o come script usando il comando python.exe disponibile nella directory di installazione seguito dal nome dello script (Fig.2).
Le istruzioni in uno script sono eseguite una alla volta, partendo dalla prima, in ordine dall’alto in basso. Se l’istruzione è una chiamata di funzione, il flusso di esecuzione va alla prima istruzione del corpo e quando è completa, il programma ritorna al punto di chiamata.


Fig.1 Interprete Python


Fig. 2 Esecuzione di script Python

Assumendo che il lettore abbia conoscenze basilari di programmazione, nel seguito vedremo le regole sintattiche di base del linguaggio di programmazione Python prendendo come riferimento la versione 3.

Operatori

+, -, *, /, // divisione intera, % modulo, ** elevamento a potenza

Operatori logici

and, or, not

Operatori relazionali

==, !=, >, <, >=, <=

Ordine delle operazioni

Parentesi, elevamento a potenza, moltiplicazione e divisione, addizione e sottrazione

Operatori Stringa

+ concatenazione, * ripetizione

Commenti

Iniziano con il simbolo #

Definizione di Funzioni


def funzione_1(argomento_1,argomento_2):
    concat=argomento_1+argomento_2
    print(concat)
    return concat

L’intestazione della funzione deve finire con i due punti, mentre il corpo deve essere indentato con lo stesso numero di spazi (generalmente 4).

Una funzione pura non modifica alcuno degli oggetti passati come argomenti e non ha altri effetti rispetto a quello di ritornare un valore.

A volte è utile per una funzione modificare gli oggetti ricevuti come parametri. In questo caso i cambiamneti sono visibili al chiamante. Funzioni che lavorano in questo modo sono chiamate modificatori.

Esecuzione condizionale

if int(x)>0:
print (“x positivo”)
elif int(x)==0:
print (“x zero”)
else:
print (“x negativo”)

input da tastiera

x=input(“Scrivi un numero\n”)
Il valore ritornato dalla funzione input() function è di tipo stringa.

Iterazione

while n > 0:
print (n)
n = n-1

for carattere in “Stringa”:
print carattere

Manipolazione di Stringhe

Sottostringhe
>>>s = ‘Una stringa molto lunga’
>>>print (s[12:17])
>>>molto

Le stringhe sono immutabili
>>> s = ‘Una stringa molto lunga’
>>> s[8] = ‘S’
>>>TypeError: ‘str’ object does not support item assignment

Metodi Stringa
>>> s1 = ‘stringa’
>>> s2 = s1.upper()
>>> print (s2)
>>>STRINGA

Operatore In
>>> ‘s’ in ‘stringa’
True
>>> ‘b’ in ‘stringa’
False

Confronto di Stringhe
if s == ‘Verde’:
print (‘Ok puoi andare’)
elif s < ‘Verde’:
print (‘La tua parola,’ + s + ‘, viene prima di Verde.’)

Le lettere maiuscole vengono prima di quelle minuscole.

Liste

Una lista è una sequenza di valori
>>>lista=[‘stringa1’,2.0,[‘sottolista1′,’sottolista2’]]
>>>print (lista[0])
stringa1

>>>lista[0]=2
>>>print (lista)
[2, 2.0, [‘sottolista1’, ‘sottolista2’]]

Scorrere una lista
for elemento in lista:
print (elemento)
2
2.0
[‘sottolista1’, ‘sottolista2’]

for i in range(len(lista)):
lista[i]=lista[i]*2
print (lista[i])
4
4.0
[‘sottolista1’, ‘sottolista2’, ‘sottolista1’, ‘sottolista2’]

Operazioni sulle liste
>>> [1, 2, 3]+[4, 5, 6]
[1, 2, 3, 4, 5, 6]

>>> [1, 2, 3] * 3
>>>[1, 2, 3, 1, 2, 3, 1, 2, 3]

>>> t = [‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’]
>>> t[1:3]
[‘b’, ‘c’]

>>> t[:4]
[‘a’, ‘b’, ‘c’, ‘d’]

>>> t[3:]
[‘d’, ‘e’, ‘f’]

Metodi su Liste
>>> t = [‘a’, ‘b’, ‘c’]
>>> t.append(‘d’)
>>> print (t)
[‘a’, ‘b’, ‘c’, ‘d’]

>>> t1 = [‘a’, ‘b’, ‘c’]
>>> t2 = [‘d’, ‘e’]
>>> t1.extend(t2)
>>> print (t1)
[‘a’, ‘b’, ‘c’, ‘d’, ‘e’]

>>> t = [‘d’, ‘c’, ‘e’, ‘b’, ‘a’]
>>> t.sort()
>>> print (t)
[‘a’, ‘b’, ‘c’, ‘d’, ‘e’]

>>> t = [‘a’, ‘b’, ‘c’]
>>> del t[1]
>>> print (t)
[‘a’, ‘c’]

>>> t = [‘a’, ‘b’, ‘c’]
>>> t.remove(‘b’)
>>> print (t)
[‘a’, ‘c’]

Liste e stringhe
>>> s = ‘stringa’
>>> t = list(s)
>>> print (t)
[‘s’, ‘t’, ‘r’, ‘i’, ‘n’, ‘g’, ‘a’]

>>> s = ‘stringa-stringa-stringa’
>>> delimiter = ‘-‘
>>> s.split(delimiter)
[‘stringa’, ‘stringa’, ‘stringa’]

>>> t = [‘stringa1’, ‘stringa2’, ‘stringa3’]
>>> delimiter = ‘  ‘
>>> delimiter.join(t)
‘stringa1 stringa2 stringa3’

Dizionari

Un dizionario costituisce una mappatura tra un insieme di indici (chiamati chiavi) e un insieme di valori.

>>> ita2eng = dict()
>>> ita2eng = {‘uno’: ‘one’, ‘due’: ‘two’, ‘tre’: ‘three’}
>>> print (ita2eng[‘due’])
two

Esempio di una funzione per contare la numerosità di lettere in una stringa
def histogram(s):
d = dict()
for c in s:
if c not in d:
d[c] = 1
else:
d[c] += 1
return d

Esempio di una funzione per ottenere una chiave da un valore
def reverse_lookup(d, v):
for k in d:
if d[k] == v:
return k
raise ValueError

Un dizionario è implementato usando una hashtable.

Un hash è una funzione che prende un valore (di qualsiasi tipo) e ritorna un intero. I dizionari usano questi interi, chiamati valori hash, per memorizzare e consulare le coppie chiave-valore.

Questo sistema lavora bene le le chiavi sono immutabili, così le liste e i dizionari non possono essere utilizzate come chiavi (ma possono essere usate come valori).

Tuple

Da un punto di vista sintattico, una tupla è una lista di valori separati da virgola:

>>> t = ‘a’, ‘b’, ‘c’, ‘d’, ‘e’

Una tupla è una sequenza di valori. I valori possono essere di qualsiasi tipo e vengono indicizzati da interi, dunque da questo punto di vista le tuple sono molto simili alle liste. La differenza sostanziale è che le tuple sono immutabili.

>>> t = tuple(‘stringa’)
>>> print (t)
(‘s’, ‘t’, ‘r’, ‘i’, ‘n’, ‘g’, ‘a’)

>>> print (t[0])
‘s’
>>> print (t[1:3])
(‘t’, ‘r’)

>>> t[0] = ‘S’
TypeError: ‘tuple’ object does not support item assignment

Assegnamento di Tuple
>>> a, b = b, a

Funzioni che accettano e ritornano valori multipli
Una funzione può tornare un solo valore, ma se il valore è una tupla, l’effetto è lo stesso di tornare valori multipli.

Le funzioni accettano un numero variabile di argomenti. Un nome di parametro che inizia con * raccoglie gli argumenti in una tupla:

def printall(*args):
print args

Il comportamento complementare è quello della dispersione. Se si ha una sequenza di valori e si vogliono passare a una funzione come argomenti multipli, si può usare l’operatore *

>>> t = (7, 3)
>>> divmod(*t)
(2, 1)

Liste e tuple
>>> s = ‘abc’
>>> t = [0, 1, 2]
>>> zip(s, t)
[(‘a’, 0), (‘b’, 1), (‘c’, 2)]

Dictionari e tuple
I dizionari hanno un metodo chiamato items che ritorna una lista di tuple dove ogni tupla è una coppia chiave-valore.

>>> d = {‘a’:0, ‘b’:1, ‘c’:2}
>>> t = d.items()
>>> print (t)
[(‘a’, 0), (‘c’, 2), (‘b’, 1)]

Le tuple possono essere utilizzate per inizializare un nuovo dizionario:

>>> t = [(‘a’, 0), (‘c’, 2), (‘b’, 1)]
>>> d = dict(t)
>>> print (d)
{‘a’: 0, ‘c’: 2, ‘b’: 1}

E’ comune utilizzare tuple come chiavi di dizionari (principalmente perchè non è possibile utilizzare liste).

elenco[nome,cognome] = numero
for nome, cognome in elenco:
print nome, cognome, elenco[nome,cognome]

Confrontare tuple
Gli operatori relazionali lavorano con tuple e altre sequenze; Python inizia confrontando il primo elemento di ogni sequenza. Se gli elementi sono uguali, si procede con gli elementi successivi, finchè non vengono trovati elementi che differiscono.

File

Leggere da un file
>>>fp = open(‘C:/file.txt’)
>>>for linea in fp:
>>>    print(linea)

Scrivere in un file
>>>fp = open(‘C:/file.txt’,’w’)
>>>fout.write(‘linea1\n’)
>>>fout.close()

Gestire le eccezioni
Molte cose possono andare male quando si cerca di leggere o scrivere in un file, per questo è preferibile gestire i problemi nel caso in cui avvengano, che è quanto viene fatto dalla dichiarazione try.

try:
fin = open(‘file_danneggiato’)
for linea in fin:
print linea
fin.close()
except:
print ‘Something went wrong.’

Classi e Oggetti

Una classe è un tipo definito dall’utente. Una definizione di classe crea un nuovo oggetto classe.

>>>class Punto(object):
>>>    “””Rappresenta un punto nello spazio a due dimensioni.”””
>>>p1=Punto()
>>>p1.x=3.0
>>>p1.y=4.0

>>>print (p1.y)
4.0

Copiare oggetti
import copy
p2 = copy.deepcopy(p1)

Metodi delle classi
class Tempo(object):
def stampa_tempo(tempo):
print ‘%.2d:%.2d:%.2d’ % (tempo.ore, tempo.minuti, tempo.secondi)
def incremento(self, secondi):
secondi += self.time_to_int()
return int_to_time(secondi)
def e_dopo(self, altro):
return self.time_to_int() > altro.time_to_int()

>>> inizio = Tempo()
>>> inizio.ore = 9
>>> inizio.minuti = 45
>>> inizio.secondi = 00
>>> stampa_tempo(inizio)
09:45:00
>>> fine = inizio.incremento(1337)
>>> fine.stampa_tempo()
10:07:17

Si noti che inizio viene assegnato al primo parametro di incremento, self. L’argomento 1337, viene assegnato al secondo parametro, secondi.

>>> fine.e_dopo(inizio)
True

Il metodo init (abbreviazione di “initialization” inizializzazione) è un metodo speciale che viene invocato quando un oggetto viene istanziato.

# inside class Time:
def __init__(self, hour=0, minute=0, second=0):
self.hour = hour
self.minute = minute
self.second = second

__str__ is a special method, like __init__, that is supposed to return a string representation of an object.

# dentro la classe Tempo:
def __str__(self):
return ‘%.2d:%.2d:%.2d’ % (self.ora, self.minuti, self.secondi)

Definendo altri metodi speciali, è possibile specificare il comportamento di operatori o tipi definiti dall’utente.

Polimorfismo
Il Polimorfismo è la capacità di alcune funzioni di lavorare con differenti tipi, questo può facilitare il riuso del codice. Ad esempio la funzione primitiva sum, che esegue l’addizione degli elementi di una sequenza, è in grado di operare su tutti quegli elementi che supportano l’addizione.

Parole chiave

Le parole chiave del linguaggio Python sono:

and del from not while as elif global or with assert else if pass yield break except import print class exec in raise continue finally is return def for lambda try

Knowage – Location Intelligence

Gli strumenti di Location Intelligence di Knowage consentono la definizione di documenti georeferenziati. In questo nuovo articolo del Blog AIKnow.info, vedremo come creare in Knowage un documento cartografico con la rappresentazione della distribuzione della popolazione per Regione. Questo sarà ottenuto caricando un livello riguardante i confini delle regioni italiane e collegando ogni elemento cartografico con le informazioni sulla popolazione provenienti da uno specifico dataset. Il risultato sarà una mappa che mostra le regioni italiane con colori differenti in base alla popolazione (Fig.1).

Chiaramente la procedura illustrata in questo semplice esempio può essere applicata a casi più complessi, dal punto di vista della cartografia di base o da quello dei dati su cui eseguire le elaborazioni.


Fig.1 Location intelligence con Knowage

Prima di tutto andremo a creare il layer cartografico in GeoJSON, uno dei formati utilizzati da Knowage.

Poichè molta cartografia viene fornita in formato SHP, e anche quella riguardante i confini delle Regioni Italiane (che può essere scaricata dall’indirizzo https://www.istat.it/it/archivio/124086, vedi Fig.2), è necessario procedere alla conversione dal formato SHP al GeoJSON impostando, allo stesso tempo, anche il sistema di coordinate utilizzato da Knowage.

Fig.2 Sito da cui scaricare il livello dei confini delle regioni italiane

Eseguiremo la conversione con GeoServer (http://geoserver.org/), un server open source che può essere utilizzato per gestire contenuto cartografico. Se si vuole installare GeoServer sulla macchina dove è installato anche Knowage, è necessario fare attenzione a selezionare per GeoServer una porta differente rispetto a quella di Knowage; la porta di default per entrambi i software è infatti la 8080.

La procedura per pubblicare un livello in formato SHP con GeoServer è disponibile a questo link:  http://docs.geoserver.org/stable/en/user/gettingstarted/shapefile-quickstart/

In breve è necessario:

  • spostare lo shape nella cartella <GEOSERVER_DATA_DIR>/data, dove  <GEOSERVER_DATA_DIR> è la root della GeoServer data directory (se non sono state fatte modifiche alla struttura file di GeoServer, il percorso è geoserver/data_dir/data/);
  • Creare un nuovo workspace
    • Navigare alla sezione Data – Workspaces e cliccare sul bottone Add New workspace;
    • Aggiungere il nome del workspace e il namespace URI (questo non deve corrispondere ad un effettivo indirizzo web valido);
    • Cliccare sul bottone Submit;
  • Creare un nuovo store
    • Navigare alla sezione Data – Stores;
    • Cliccare sul bottone Add new Store;
    • Tra i formati disponibili, scegliere Shapefile, questo aprirà la pagina New Vector Data Source;
    • Configurare le Basic Store Info:
      • Selezionare il workspace creato in precedenza;
      • Inserire il Data Source Name e una breve descrizione;
    • In Connection parameters navigare fino all’ URL dello shapefile;
    • Cliccando sul bottone Salva si verrà ridiretti alla New Layer page;
  • Creare un layer
    • Nella pagina New Layer cliccare su Publish accanto al nome del layer;
    • La pagina Edit Layer definisce i dati e i parametri di pubblicazione per il layer. Inserire un breve titolo e un Abstract;
    • A questo punto è fondamentale definire il sistema di riferimento per le  coordinate utilizzato da Knowage. Per farlo è necessario impostare  Declared SRS a EPSG:4326 e SRS handling a Reproject native to declared.

 Fig.3 Definizione del Sistema di riferimento delle Coordinate

    • Generare i limiti del livello cliccando sui link Compute from data e poi su Compute from native bounds;
    • Cliccare sul tab Publishing in alto sulla pagina;
    • Sotto WMS Settings, assicurarsi che il Default Style sia impostato a linea;
    • Finalizzare la configurazione del layer scorrendo fino in fondo alla pagina e cliccando Save.
  • Anteprima del layer
    • Aprire la sezione Layer Preview e trovare il livello appena creato;
    • Cliccare sul link OpenLayers nella colonna Common Formats;
    • Verrà caricata una mappa OpenLayer in un nuovo tab che mostrerà i dati dello shapefile con lo stile linea di default. E’ possibile utilizzare questa anteprima di mappa per eseguire lo zoom e  il pan degli elementi cartografici e mostrare gli attributi delle caratteristiche (Fig.4).

Fig.4 Anteprima della mappa OpenLayer

Si noti che ogni elemento cartografico ha due attributi chiamati COD_REG e REGIONE, che verranno utilizzati per collegare le informazioni cartografiche con quelle provienti dal dataset.

Per ottenere il file GeoJSON tornare al menu Data – Layer Preview, e nel combo box All Formats selezionare il formato GeoJSON (Fig.5)


Fig.5 Creazione del GeoJSON attraverso lo strumento Layer Preview

Ora accedendo a Knowage come amministratore è possibile definire il catalogo dei layer. Cliccando su Catalogs – Layer Catalogs si presenta l’interfaccia in Fig. 6. Specificare una etichetta e un nome, scegliere File come Layer Type e selezionare il GeoJSON appena creato.

Completare le altre informazioni richieste: Layer label, Layer name, Layer ID e Layer order (selezionare 1 come valore).

Infine selezionare il ruolo che può accedere alla risorsa (/demo/admin e /demo/user in questo esempio).


Fig.6 interfaccia di creazione del catalogo dei livelli

Per andare avanti abbiamo a questo punto necessità di un data source con le informazioni da collegare al contenuto cartografico. Facendo riferimento a quanto illustrato nel post  Knowage – Interrogare database in maniera visuale con QBE (Query by Example) partendo da una tabella con i dati della popolazione per Regione (Fig.7), andremo a generare un dataset di tipo Flat (Fig.8)


Fig.7 dati di popolazione delle regioni italiane


Fig. 8 definizione del Data Set

Con i Layer data e i Data Set pronti all’uso, è ora possibile generare un documento di analisi Georeferenziata.

Questo può essere fatto accedendo a Knowage come utente e cliccando sull’icona My workspace, e sulla cartella Analysis.

Cliccando sull’icona Add, verrà aperto il GIS Document designer. Qui è necessario selezionare il dataset (che per questo esempio è POP_REG, Fig.9).


Fig.9 Definizione del dataset nel GIS Document designer

Poi deve essere selezionato il layer dalla lista di quelli disponibili. Per questo esempio abbiamo definito un layer chiamato itareg (Fig.5 and Fig.10)


Fig. 10 selezione del layer nel GIS Document designer

A questo punto si possono specificare una o più colonne attraverso le quali collegare layer e dataset (Fig.11).


Fig. 11 Impostazione delle colonne di  join nel GIS Document designer

Infine si può aggiungere un indicatore e un filtro definendo una misura e un’etichetta e configurare il menu della mappa (Fig.12).


Fig. 12 Indicatori, filtri e configurazione del menu della mappa

Cliccando sul bottone salva, verrà salvato il template e si potrà visualizzare un’anteprima del documento cartografico cliccando su Edit Map (Fig.13). Nel menu sulla destra della pagina sono a disposizione strumenti per interagire con la mappa, con i livelli e definire configurazioni personalizzate.

Fig. 13 Documento di Location intelligence

Knowage – Monitorare gli obiettivi di business con i documenti KPI

Un Key Performance Indicator è un indice, che consiste in una o più metriche, che può essere utilizzato per monitorare quanto efficacemente un’organizzazione sta perseguendo gli obiettivi chiave. In questo articolo del Blog AIKnow.info , vedremo come Knowage possa essere utilizzato per creare Documenti KPI (Fig.1)


Fig.1 Un documento KPI

Il primo passo è quello di definire una nuova misura/regola; questo può essere fatto a partire dal menu Kpi Model – Measure/Rule Definition. Cliccando sull’icona con il segno più, si apre l’interfaccia in Fig.2 dove è possibile definire la query.

Questo esempio suppone che la misura di interesse sia il numero di prodotti creati in una linea in un’ora e che questo numero venga inserito in una tabella con la stessa cadenza (Fig.3).


Fig.2 Interfaccia di definizione di una nuova misura

Fig.3 contenuto della tabella

Nel tab Metadata  è possibile definire una tipologia e una categoria per ogni valore selezionato attraverso la query, mentre il tab Preview consente di controllare il risultato delle configurazioni.

I KPI possono essere definiti dal menu KPI Model-KPI Definition. Il bottone aggiungi apre l’interfaccia di Fig. 4. Usando il bottone CTRL e la barra spaziatrice il sistema mostra tutte le misure definite.


Fig.4 Menu di definizione dei KPI

Una volta scelta la misura, cliccando sulla stessa può essere scelta la funzione da applicare a quel valore (Fig.5). Nel nostro esempio controlleremo il valore minimo assunto dal numero di prodotti costruiti nella linea di produzione. Chiaramente il calcolo può essere più complesso e coinvolgere varie misure e operatori.


Fig.5 Selezione della funzione da applicare alla misura

Il tab Cardinality consente di definire il livello di raggruppamento per gli attributi delle misure definite.

I valori limite possono essere impostati usando il tab Threshold (Fig.6)  dove si possono specificare l’etichetta i valori minimo e massimo e i colori associati.


Fig.6 Definizione dei valori limite

L’ultimo passo è quello di definire un nuovo Scheduler. Nel menu KPI Model-KPI Scheduler, usando l’icona con il segno più si apre l’interfaccia di Fig.7, dove  nel tab KPI, può essere aggiunta un’associazione (Fig.8)


Fig.7 Interfaccia Nuova schedulazione


Fig.8 Associazione del KPI

Nel tab Frequency, può essere definita la data di inizio e di fine e la periodicità di esecuzione.


Fig.9 Interfaccia riguardante nuova schedulazione

Ora può essere creato un nuovo documento per visualizzare il KPI. In Fig. 10 è riportata la configurazione base.


Fig.10 Interfaccia di definizione di un nuovo Documento KPI

In Fig.11 è possibile vedere l’interfaccia di creazione del template dove  configurare il vari aspetti del documento.


Fig.11 Interfaccia di progettazione del documento KPI

Il risultato delle precedenti configurazioni è visibile in Fig.12

Fig.12 Documento KPI

Knowage – Analisi OLAP

L’analisi OLAP (Onlyne Analytical Processing) consente di analizzare grandi quantità di dati in tempo reale, con tempi di risposta veloci per ottenere un’alta interattività. Questo è usualmente ottenuto attraverso l’uso di tabelle pivot: in Fig.1 è rappresentato un documento OLAP di Knowage che contiene una tabella pivot come parte principale.

In questo articolo del Blog AIKnow.info  vedremo come creare un documento OLAP con Knowage, a partire dal dataset descritto nel post Knowage – Interrogare database in maniera visuale con QBE (Query by Example)


Fig.1 Documento OLAP Knowage

OLAP è basato sull’Analisi Multidimensionale. Mentre un database relazionale immagazzina i dati in forma di righe e colonne, un dataset multidimensionale, in breve chiamato cubo, è composto da dimensioni, gerarchie e misure.

Il primo passo per creare un documento di analisi OLAP con Knowage è scrivere un nuovo Schema utilizzando Mondrian, uno strumento ROLAP che mappa, mediante un file XML, strutture OLAP (cubi, dimensioni e attributi) su tabelle e colonne di un database relazionale. Informazioni di maggior dettaglio sono disponibili a questo indirizzo https://mondrian.pentaho.com/.

Per procedere è necessario innanzitutto creare uno schema a stella, che consiste in una tabella dei fatti che referenzia due o più tabelle di dimensioni, come illustrato in Fig.2


Fig.2 Schema a stella

Dai dati della tabella “0054_consumo_energia” (vedi articolo Knowage – Interrogare database in maniera visuale con QBE (Query by Example)), è possibile generare uno schema a stella nel quale la tabella dei fatti (Fig.3) contiene il dato sul consumo di energia  (colonna “dato”), e le chiavi esterne “territorio” verso la tabella della dimensione Città  (Fig.4) e “anno”  verso la tabella di dimensione Tempo (Fig.5).

Fig. 3 Tabella dei fatti

Fig.4 Tabella delle dimensione Città


Fig.5 Tabella della dimensione tempo

Con lo schema a stella disponibile, è possibile creare lo schema Mondrian, che consiste, in poche parole, in un file XML dove sono specificate le caratteristiche delle dimensioni e dei cubi. In Fig.6 è possibile vedere in dettaglio il file XML creato per questo esempio. La sua interpretazione è abbastanza semplice, indicazioni di dettaglio riguardanti la scrittura dello schema si trovano a questo indirizzo https://mondrian.pentaho.com/documentation/schema.php


Fig.6 Schema Mondrian

Una volta scritto, lo schema può essere caricato in Knowage attraverso il Menu Catalogs-Mondrian schemas catalog (Fig.7)


Fig.7 Caricamento dello schema Mondrian

A questo punto il documento può essere creato utilizzando il Menu Document Browser – New document – Generic Document (Fig.8). I campi Label e Name sono obbligatori, Type deve essere impostato a On-line analytical processing, Engine a OLAP Engine, Data Source a quello in uso (nel caso in esempio il nome del Data Set è MySQL). Poi è necessario specificare la cartella per il documento utilizzando l’albero nella parte destra della pagina.


Fig.8 Creazione di un nuovo documento

Cliccando sull’icona Template build, si apre l’interfaccia OLAP designer (Fig.8), dove è necessario scegliere come Type of Template Mondrian, come Mondrian Schema quello caricato (Fig.6 e 7) e come Cube quello definito nel file XML.


Fig.9 Interfaccia OLAP Designer

Cliccando su Start presente in alto a destra, si apre il documento (Fig.10), la cui parte centrale è costituita dalla tabella pivot che può essere utilizzata per analizzare i dati.

Attraverso il pannello degli assi si possono piazzare gerarchie (rappresentate con filter card) sulle colonne o sulle righe, posizionarle in ordine particolare, scambiare gli assi.

Cliccando sull’icona posizionata in alto a destra sulla pagina si apre la barra laterale che consente di scegliere diverse rappresentazioni dei dati e differenti strumenti di analisi.

Fig.10 Documento OLAP

Knowage – Creare Report con BIRT

I Report possono essere utili quando dati di interesse devono essere esportati periodicamente in un formato specifico, anche seguendo un modello predefinito, per monitorare processi e supportarne la gestione.

Con il Knowage Report Designer Tool, disponibile all’indirizzo  https://download.forge.ow2.org/knowage/, è possibile creare e pubblicare report su un Server Knowage.

In questo articolo del Blog AIKnow.info, che segue quello sui Cockpit, vedremo come creare un Report utilizzando BIRT, una piattaforma open source usata per creare visualizzazioni dati e report http://www.eclipse.org/birt/.

Una volta scaricato e installato, il Knowage Report Designer Tool può essere connesso a Knowage Server, dando così la possibilità di scaricare e deployare  Report.

Il primo passo da seguire è quello di aprire il Knowage Report Designer Tool, creare un nuovo progetto (dal menu File-New-Knowage Project o attraverso l’icona Knowage) e aggiungere un nuovo server (tasto destro su Resources – Server icon), vedi Fig. 1.

Fig.1 Creare un nuovo progetto e aggiungere un nuovo server

Si noti che nella configurazione del nuovo server, è necessario sceglierne almeno uno come Active (Fig.2)

Fig.2 Configurazione e test di un nuovo server

Per creare un nuovo Report, è sufficiente cliccare con il tasto destro sull’icona della cartella Business Analysis e scegliere il comando Report-Report with Birt (Fig.3)


Fig.3 Nuovo report con Birt

Una volta creato, il report può essere disegnato facendo doppio click sullo stesso e aprendo la Report Designer Perspective (Fig.4 and 5)

Fig.4 Scelta della prospettiva

Fig.5 Prospettiva Report Design

Come primo passo deve essere creato un nuovo Data Source. Questo può essere fatto con il tasto destro sull’icona specifica in Fig.5. Si apre una wizard (Fig. 6) dove, scegliendo Knowage Server Data Source dalla lista, è possibile recuperare i Data Set già definiti in Knowage.

Fig.6 Creare un nuovo Data Source

Fig.7 Configurazione del Data Source

Una volta definito il Data Source, può essere creato un nuovo Data Set attraverso il tasto destro sull’icona della prospettiva Report Design (Fig.5). Deve essere innanzitutto fornito un nome al Data Set (Fig.8), poi specificata una etichetta (Fig.9). In questo passo è obbligatorio specificare la stessa etichetta utilizzata dal Data Set Knowage Server.

Fig.8 Creazione di un nuovo Data Set

Fig.9 Configurazione del Data Set

E’ poi possibile configurare ulteriormente il Data Set (Fig.10)

Fig.10 Configurazione del Data Set

Una volta che il Data Set è disponibile, la generazione del report può essere fatta semplicemente trascinandolo sull’area di lavoro e scegliendo le colonne visibili (Fig.11 and 12). Chiaramente le caratteristiche del report possono essere modificate dall’interfaccia Property Editor (Fig.13).

Fig.11 Generazione del Report

Fig.12 Generazione del Report


Fig. 13 Interfaccia Property Editor

A questo punto è possibile testare il report, cliccando con il tasto destro sullo stesso e scegliendo il comando Report – Run Report (Fig.14).

Il comando apre il browser predefinito e, se tutto funziona correttamente, verrà visualizzato il report creato (Fig.15).

Fig.14 Test del report attraverso il comando Run Report

Fig.15 Anteprima del Report

Ora, tornando alla prospettiva Knowage, è possibile eseguire il deploy del  report sul server, cliccando sullo stesso con il tasto destro e scegliendo l’icona  Deploy (Fig.16). Il comando apre una wizard dove è necessario specificare  etichetta, nome, descrizione e Data Source (Fig.17).

Fig. 16 Deploy del report


Fig.17 Wizard di deploy del Report

Una volta eseguito il deploy, il report è disponibile in Knowage, aprendo il Document Browser (Fig.18).


Fig.18 Document Browser di Knowage

Cliccando sull’icona play, il report sarà generato, è potrà essere esportato in uno dei formati disponibili (Fig.19)


Fig.19 Generazione ed esportazione del Report

Knowage – Monitorare dati con i Cockpit

In questo articolo del Blog AIKnow.info, che segue quello riguardante il Query by Example, vedremo come usare Knowage per creare un Cockpit al fine di monitorare l’andamento di dati di interesse. Creeremo un esempio dove, partendo dai dati della popolazione residente, sarà possibile vedere l’evoluzione di questo valore per anno e per città. Chiaramente questo esempio può essere esteso ad altre aree, come quelle connesse alle metriche aziendali.


Fig.1 Cockpit di Knowage che rappresenta la popolazione residente
per città e anno


Fig. 2 – Creazione del Data Set

Dall’interfaccia di definizione del Data Set, utilizzando l’icona della matita, è poi necessario definire se un campo è un attributo o una misura (Fig.3).


Fig. 3 Definizione dei metadati dei campi 

Per la profilazione degli utenti, è utile definire una categoria specifica per il Data Set (in questo esempio Dati_Italia). Questo può essere fatto dal Menu Server Settings – Domain Management (Fig.4).


Fig. 4 Definizione di una nuova categoria

Una volta definita, la categoria può essere aggiunta ad uno specifico ruolo usando il Menu Profile Management – Roles Management (Fig.5)


Fig. 5 Associazione di una categoria a un ruolo

Dall’interfaccia di configurazione del Data Set, selezionando il Tab TYPE, è possibile definire le caratteristiche del data set (Fig.6) e avere un’anteprima del Data Set creato (Fig.7).


Fig.6 definizione delle caratteristiche del Data Set


Fig.7 Anteprima del Data Set

Ora, accedendo a Knowage come utente, nell’area Analysis del menu Workspace, è possibile cliccare sull’icona Create Analysis e scegliere  Cockpits.

Questo aprirà una pagina vuota che può essere editata usando gli strumenti disponibili nel menu accessibile dall’icona a sandwich.


Fig.8 Menu di gestione del Cockpit

L’icona Add Widget apre l’interfaccia in Fig. 9 dove è possibile scegliere gli elementi da aggiungere al Cockpit.


Fig.9 Widget disponibili per creare il Cockpit

Nel nostro esempio aggiungeremo una tabella e un grafico. In Fig. 10 è rappresentata l’interfaccia di configurazione del Table Widget. E’ costituita da 4 tab dove è possibile definire il comportamento di colonne, stili, cross navigazione e filtri.


Fig.10 Interfaccia di configurazione del Table widget

In Fig.11 è rappresentata l’interfaccia di configurazione del Chart widget. Questa è costituita da 5 tab dove è possibile configurare i Dataset, progettare grafici con uno specifico motore, e definire il comportamento di stili, cross navigazione e filtri.


Fig.11 Interfaccia di configurazione del Chart widget

Il Chart Engine Designer consente di scegliere lo stile del grafico (Fig.11) e la sua struttura (Fig.12) costituita da Categories  (asse x) e Series (asse y). Da notare che per le categorie è necessario scegliere un attributo, mentre per le serie una misura (Fig.3).


Fig.12 intefaccia di configurazione del widget Chart 

In Fig.13 è rappresentato il risultato dei precedenti passi: una tabella contenente tutti i record selezionati dal dataset e un grafico che rappresenta per anno, la somma delle misure “Dato”.


Fig.13 Cockpit risultante dalle configurazioni descritte

Un’interessante funzione di Knowage è quella rappresentata in Fig.14 dove, scegliendo una città e facendo doppio click sulla colonna “Territorio”, i dati della tabella vengono filtrati per questo attributo e il contenuto del grafico è aggiornato di conseguenza.


Fig.14 Cockpit risultante dalla selezione di una città

La città scelta può essere modificata dal widget di selezione (Fig.15).


Fig.15 Widget di Selezione

Knowage – Interrogare database in maniera visuale con QBE (Query by Example)

Knowage (www.knowage-suite.com) è una suite open source di Business Intelligence, che discende dal ben conosciuto SpagoBI.

In questo articolo del Blog di AIKnow.info, vedremo come creare un QBE (Query By Example), utile quando si vuole dare all’utente finale la possibilità di interrogare database in maniera visuale, cioè senza usare linguaggi di interrogazione come SQL.

Nella seguente immagine (Fig.1) è rappresentata l’interfaccia del QBE. A sinistra sono disponibili le tabelle riguardanti i i fatti che possono essere analizzate semplicemente trascinando gli attributi di interesse nel pannello centrale , dove è anche possibile ordinarli, raggrupparli, filtrare le informazioni risultanti usando vari principi e così via.

Fig.1 L’interfaccia del Query By Example di Knowage

Nel seguito vedremo la procedura da seguire per ottenere il precedente risultato. Assumiamo di avere Knowage installato e di disporre di uno schema di database dedicato. Anche se i dati di interesse risiedono già in un database, è comunque buona norma lavorare in uno schema separato al fine di evitare interferenze tra i sistemi informativi operazionali e quelli di Business Intelligence. In questo modo è possibile gestire meglio anche i processi di ETL (Extract, Transform and Load), una parte essenziale di un sistema di Business Intelligence.

In questo esempio sono stati utilizzati alcuni data set prelevati dal portale open data dati.italiaitalie.it che sono stati caricati in uno schema MySQL dedicato usando l’utility Import Wizard disponibile nel software Toad for MySQL (Fig.2).


Fig.2 Import Wizard di Toad per MySQL

Come risultato in MySQL sono a disposizione 7 tabelle riguardanti alcuni fatti di interesse: popolazione residente assoluta e relativa, consumi di energia, depositi in banca, reddito disponibile, impieghi bancari totali, furti nelle abitazioni. Queste tabelle possono essere collegate attraverso gli attributi Territorio e Anno.


Fig.3 dati caricati in My SQL

Ora possiamo aprire Knowage e applicare le configurazioni richieste per costruire il QBE.
Il primo passo è quello di definire un nuovo Data Source. Questo è possibile  accedendo a Knowage come amministratore e usando il menu Data Source. La Fig. 4 illustra le configurazioni per MySQL.

Fig.4 Configurazione del Data source

Il secondo step è definire il Business Model: questo è possibile accedendo al Catalogs-Business Model catalog e fornendo le informazioni richieste (Fig.5).
Al fine di profilare semplicemente l’accesso degli utenti ai dati, è importante definire una categoria specifica (ITALIA) per il Business Model. Questo può essere fatto attraverso il Menu Impostazioni Server – Gestioni domini (Fig.6)


Fig. 5 Interfaccia di definizione di un nuovo Business Model

Fig. 6 Definizione di una nuova categoria di Business Model

Una volta fornite le informazioni richieste in Fig.5, cliccando su Salva viene abilitato il bottone di creazione del Meta modello. Il primo passo per definire il Meta modello è quello di scegliere le tabelle da includere dalla lista che proviene dal Data source (Fig.7).

Fig.7 Selezione delle tabelle dal Data source

Cliccando su continua è possibile editare il Business Model. E’ importante definire per ogni tabella la chiave da usare (Fig.8) e la relazione tra tabelle (Fig.9)


Fig.8 Selezione delle chiavi


Fig.9 Definizione delle relazioni

Una volta create tutte le relazioni, tornando al Menu Catalogs – Business Models catalog, e selezionando quello appena creato, è disponibile un nuovo bottone GENERATE (Fig.10 e 11) che consente la creazione del datamart richiesto per interrogare il Meta modello dall’interfaccia dello spazio di lavoro.


Fig.10 Interfaccia di creazione del Modello di Business con
disponibile il bottone GENERATE


Fig.11 Dialog box per confermare la creazione del Datamart

Perchè un utente possa lavorare con il Meta modello appena creato, è necessario attribuirgli i necessari permessi. Questo può essere fatto accedendo al menù Profile Management – Role Management e permettendo la categoria di Business Model ITALIA al ruolo desiderato (Fig.12). Se il ruolo o l’utente non è già presente, è possibile aggiungerlo attraverso il menu Roles Management o Users Management nella sezione Profile Management.


Fig.12 Aggiunta della categoria ITALIA al ruolo dell’utente

Ora accedendo a Knowage con un utente con il profilo corretto, è possibile trovare il Meta modello nella sezione Data-Models (Fig.13).


Fig.13 workspace dell’utente con il meta modello disponibile

Cliccando sull’icona della lente di ingrandimento si aprirà l’interfaccia QBE (Fig.14). Nella colonna di sinistra è possibile trovare le tabelle disponibili, e per ognuna i relativi attributi. E’ possibile selezionare quelli di interesse trascinandoli nella finestra dell’editor di Query. qui è possibile definire varie proprietà da applicare all’attributo (Alias, Ordinamento etc.) e i filtri necessari.


Fig.14 Interfaccia QBE

Quando si è certi degli attributi e delle relative proprietà, è possibile vedere un’anteprima del report (Fig. 15) usando il comando in alto a destra del pannello di editing della Query. Questo può essere salvato per successivi usi attraverso l’icona del floppy disk.


Fig.15 Anteprima del Report