Progettazione del miglioramento del sistema I.A.F.C.E.R.
Si elencano di seguito gli elementi progettuali target del seguente progetto:
PRESTAZIONE O CARATTERISTICA |
SITUAZIONE PRE-PROGETTO E VALUTAZIONE |
SITUAZIONE POST- PROGETTO E VALUTAZIONE |
Reperimento delle informazioni riguardanti l’azienda cliente; tempo richiesto. |
Automatizzato con interfaccia step-to-step; alcuni minuti
|
Automatizzato con interfaccia step-to-step miglorata con parametri di misurazione di impatto ambientale; alcuni minuti
|
● reperimento dati anagrafici |
SI, automatico |
SI, automatico |
● reperimento codici ATECO |
SI, manuale |
SI, automatico |
● reperimento dati di bilancio |
SI, automatico |
SI, automatico |
● reperimento dati di mercato
|
SI, automatico |
SI, automatico |
Misurazione del Carbon Footprint |
NO |
SI
|
Matching automatico dei bandi o delle agevolazioni appropriate all’utente in base al grado di Corporate Environmental Responsability |
NO |
SI
|
Schede interattive dei bandi |
NO |
SI
|
Utilizzo di algoritmi intelligenti per Corporate Environmental Responsability |
NO |
SI
|
Diagnosi di bilancio; tempo richiesto |
SI, automatico; alcuni minuti
|
SI, automatico; alcuni minuti; usabilità migliorata
|
Analisi rischio di insolvenza aziendale; tempo richiesto |
SI, automatico; alcuni minuti
|
SI, automatico; alcuni minuti; usabilità migliorata
|
Suggerimento strategie per migliorare i dati di bilancio |
SI, automatico; alcuni minuti
|
SI, automatico; alcuni minuti; usabilità migliorata
|
Calcolo predittivo dei risultati ottenuti dalle iniziative proposte |
SI, automatico; alcuni minuti
|
SI, automatico; alcuni minuti; usabilità migliorata
|
Fornitura di una gamma completa di soluzioni per la finanza agevolata |
Ottimo |
Eccellente |
Rapporto qualità prezzo |
Ottimo |
Eccellente |
Ne consegue il seguente elenco dei requisiti dell’improvement della progettazione:
Codice requisito |
Area |
Requisito funzionale, tecnico, archietturale o infrastrutturale |
Req01 |
Data sorucing |
guidare la raccolta delle informazioni necessarie al cliente; |
Req02 |
Data sourcing; |
reperire sulla base delle informazioni raccolte i relativi documenti richiesti da apposite banche dati di enti pubblici o privati; |
Req03 |
Data sourcing; Data processing |
Misurazione del Carbon Footprint |
Req04 |
Data processing |
riconoscere e selezionare le informazioni necessarie da tali documenti, uniformare la formattazione dei dati ed elaborarli secondo schemi prestabiliti per ricavare parametri utili; |
Req05 |
Algoritmo, Engine, Intelligenza artificiale |
Permettere che il funzionamento degli algoritmi si adatti in modo intelligente alle specifiche esigenze imprenditoriali dell’utente finale, ad esempio modulando la selezione dei parametri da elaborare in funzione della tipologia di investimento (ad esempio acquisto di macchinari, formazione, innovazione di prodotto o di processo ecc) o di strategia di miglioramento di impatto ambientale (ad esempio certificazioni come. Global Gap, FSC, Ecolabel, VeganOK) per cui si dimostra interesse. |
Req06 |
Architecture Documentation |
confrontare i parametri dell’azienda cliente con parametri individuati nelle normative e negli atti pubblici inerenti la Corporate Environmental Responsability, la finanza agevolata e la performance reputazionale; |
Req07 |
Interoperability |
applicare adeguati algoritmi predittivi per supportare l’interpretazione dei dati; |
Req08 |
Interfaccia |
Fornire all’utente finale, con il supporto di contenuti grafici e testuali, una serie completa di tutte le strategie di Corporate Environmental Responsability finanziare e reputazionali confacenti alle caratteristiche specifiche dell’azienda cliente, in maniera tale da guidare l’utente nella valutazione. |
Req09 |
Interfaccia |
Fornire una diagnostica finanziaria completa dell’attività dell’azienda cliente permettendo di risalire, anche ad esempio tramite la presentazione a video di grafici descrittivi, in maniera semplice e veloce alle cause che determinano eventuali vulnerabilità di bilancio, rischi di insolvenza o impatti ambientali negativi. |
Req10 |
Interfaccia, Control Room |
Interfacciarsi con un sistema informativo interno di più alto livello da cui ad esempio ricevere le informazioni riguardanti la percentuale di successo delle strategie finanziare e di miglioramento di impatto ambientale suggerite in casi analoghi in passato, e verso cui fornire informazioni riguardanti le elaborazioni effettuate, le scelte degli utenti, il time on page nella navigazione ecc. |
Req11 |
Interfaccia |
Schede interattive dei bandi |
Req12 |
Interfaccia |
Calcolo predittivo dei risultati ottenuti dalle iniziative proposte con usabilità migliorata |
Req13 |
Interfaccia |
Fornitura di una gamma completa di soluzioni per la finanza agevolata migliorata |
Req14 |
Economics |
Rapporto qualità prezzo ottimizzato |
Inoltre sono stati analizzati i requisiti minimi software. Trattandosi di una applicazione web, il requisito è un browser web Firefox, Chrome, Safari, Edge, Internet Explorer o similari.
Il software consigliato è nella tabella sottostante:
Browser |
Versione minima |
Chrome |
70 |
Internet Explorer |
11 |
Edge |
18 |
Firefox |
63 |
Safari |
12 |
Opera |
56 |
IOS Safari |
12 |
Chrome for Android |
70 |
Introduzione
Sono state individuate le specifiche dell’architettura di sistema necessaria ad interfacciare la piattaforma on line con gli engine di data-mining, con particolare riguardo alla definizione della modalità di selezione degli algoritmi che il sistema deve utilizzare e ai protocolli di comunicazione tra i moduli software.
Partendo dalle specifiche funzionali stabilite, si è è proceduto alla progettazione di dettaglio di tutti i moduli software richiesti. In particolare è stato progettato il core del sistema di data-mining e i requisiti funzionali di ogni modulo. Sono state inoltre definite le interfacce e le pagine che costituiranno le parti fondamentali della piattaforma on-line. Per ogni scenario di analisi è stato individuato il tipo di algoritmo da adottare. E’ tato inoltre inoltre predisposta l’integrazione del modulo di data mining con le banche dati e le interfacce della piattaforma on-line.
A.2.1 Miglioramento delle linee guida di business analytics da implementare nel sistema I.A.F.C.E.R. - Progettazione del modulo software di interfaccia utente, con questionario step-to-step per i dati aziendali utili all’analisi dell’impatto ambientale
Requisiti del modulo software di interfaccia utente, con questionario step-to-step per i dati aziendali utili all’analisi dell’impatto ambientale
Si riassumono di seguito i requisiti dell’improvement della progettazione di competenza della presente attività:
Codice requisito |
Area |
Requisito funzionale, tecnico, archietturale o infrastrutturale |
Req01 |
Data sorucing |
guidare la raccolta delle informazioni necessarie al cliente; |
Req02 |
Data sourcing; |
reperire sulla base delle informazioni raccolte i relativi documenti richiesti da apposite banche dati di enti pubblici o privati; |
Req03 |
Data sourcing; Data processing |
Misurazione del Carbon Footprint |
Req08 |
Interfaccia |
Fornire all’utente finale, con il supporto di contenuti grafici e testuali, una serie completa di tutte le strategie di Corporate Environmental Responsability finanziare e reputazionali confacenti alle caratteristiche specifiche dell’azienda cliente, in maniera tale da guidare l’utente nella valutazione. |
Req09 |
Interfaccia |
Fornire una diagnostica finanziaria completa dell’attività dell’azienda cliente permettendo di risalire, anche ad esempio tramite la presentazione a video di grafici descrittivi, in maniera semplice e veloce alle cause che determinano eventuali vulnerabilità di bilancio, rischi di insolvenza o impatti ambientali negativi. |
Req10 |
Interfaccia, Control Room |
Interfacciarsi con un sistema informativo interno di più alto livello da cui ad esempio ricevere le informazioni riguardanti la percentuale di successo delle strategie finanziare e di miglioramento di impatto ambientale suggerite in casi analoghi in passato, e verso cui fornire informazioni riguardanti le elaborazioni effettuate, le scelte degli utenti, il time on page nella navigazione ecc. |
Req11 |
Interfaccia |
Schede interattive dei bandi |
Req12 |
Interfaccia |
Calcolo predittivo dei risultati ottenuti dalle iniziative proposte con usabilità migliorata |
Progettazione di dettaglio del modulo software di interfaccia utente, con questionario step-to-step per i dati aziendali utili all’analisi dell’impatto ambientale
Codice requisito |
Area |
Requisito funzionale, tecnico, archietturale o infrastrutturale |
Req01 |
Data sourcing |
guidare la raccolta delle informazioni necessarie al cliente; |
Tecniche e tecnologie previste
Framework python Django. Django è un framework web Python di alto livello che consente un rapido sviluppo di siti web sicuri e manutenibili.
Si propone il miglioramento dell’interfaccia attraverso implementazione del package specifico per la raccolta di dati tramite questionario Django survey
Si riportano gli step necessari per l’implementazione
1) Aggiunta ai requisiti tramite comando pip
echo 'django-survey-and-report' > requirements.txt
pip install -r requirements.txt
Aggiungere bootstrapforme surveynel INSTALLED_APPSnelle impostazioni:
INSTALLED_APPS = [
# Your own installed apps here
]
from pathlib import Path
CSV_DIRECTORY = Path("csv") # Define the directory where csv are exported
TEX_DIRECTORY = Path("tex") # Define the directory where tex files and pdf are exported
INSTALLED_APPS += [
'bootstrapform',
'survey'
]
Aggiungi una voce URL a urls.py del tuo progetto, ad esempio:
from django.conf import settings
from django.conf.urls import include, url
urlpatterns = [
# Your own url pattern here
]
if 'survey' in settings.INSTALLED_APPS:
urlpatterns += [
url(r'^survey/', include('survey.urls'))
]
Si possono inoltre aggiungere le seguenti opzioni:
# Permit to open the csv in excel without problem with separator
# Using this trick : https://superuser.com/a/686415/567417
EXCEL_COMPATIBLE_CSV = True
# The separator for questions (Default to ",")
CHOICES_SEPARATOR = "|"
# What is shown in export when the user do not answer (Default to "Left blank")
USER_DID_NOT_ANSWER = "NAA"
# Path to the Tex configuration file (default to an internal file that should be sufficient)
from pathlib import Path
TEX_CONFIGURATION_FILE = Path("tex", "tex.conf")
# Default color for exported pdf pie (default to "red!50")
SURVEY_DEFAULT_PIE_COLOR = "blue!50"
Utilizzando l'interfaccia di amministrazione è possibile creare sondaggi, aggiungere domande, fornire categorie di domande e contrassegnarle come richieste o meno. È possibile definire le scelte per le risposte utilizzando parole separate da virgole:
Codice requisito |
Area |
Requisito funzionale, tecnico, archietturale o infrastrutturale |
Req02 |
Data sourcing; |
reperire sulla base delle informazioni raccolte i relativi documenti richiesti da apposite banche dati di enti pubblici o privati; |
Per quanto riguarda il modulo software di interfaccia utente si prevede che il reperimento di documenti verrà effettuato tramite API connect.myclimate.org per quanto riguarda la performance ambientale e tramite API di talkwalker per quanto riguarda la company reputation.
Codice requisito |
Area |
Requisito funzionale, tecnico, archietturale o infrastrutturale |
Req03 |
Data sourcing; Data processing |
Misurazione del Carbon Footprint |
Per quanto riguarda la misurazione dell’impatto ambientale si prevede l’utilizzo delle API fornite da https://connect.myclimate.org/
Si prevede la raccolta dei seguenti dati:
nome necessario |
string |
nazione necessario |
string Codice di 2 lettere in maiuscolo (ISO 3166-1 alpha-2) |
numero di dipendenti necessario |
numero < float > > = 0 Numero di posti a tempo pieno. Due dipendenti al 70% danno un valore di 1.4. |
riscaldata_area |
numero < float > > = 0 nel m2 |
stima_energia necessario |
string Predefinito: "0" Enum : "0" "1" 1se il consumo di energia non è noto e dovrebbe essere stimato. In questo caso, non forniscono power_consumption_kwh, green_electricity, oil_liters, natural_gas_m3, biogas_m3, district_heat_kwh, wood_pellets_kwh, wood_chips_kwh, heat_pump, cooling_agent_type,cooling_agent_power |
power_consumption_kwh |
numero < float > > = 0 In kWh. Non fornire se estimate_energyè1 |
green_electricity |
booleano non fornire se lo estimate_energyè1 |
litri_olio |
numero < float > > = 0 In litri. Non fornire se estimate_energyè1 |
gas_aturale_m3 |
numero < float > > = 0 in m3. Non fornire se estimate_energyè1 |
biogas_m3 |
numero < float > > = 0 In m3. Non fornire se estimate_energyè1 |
district_heat_kwh |
numero < float > > = 0 in kWh. Non fornire se estimate_energyè1 |
pompa di calore |
booleano non fornire se lo estimate_energyè1 |
cooling_agent_type |
string Enum : "R-134a" "R-22 (Standard)" "R-401A" "R-402B" "R-407A" "R-407C" "R-410A" "R-170" "R-290" "R-717" "R-1270" "R-718" non fornire se lo estimate_energyè1 |
consider_advanced_energy_inputs |
string Predefinito: "0" Enum : "0" "1" Deve essere 1se qualcuno di wood_chips_kwh, biogas_m3, district_heat_kwh, heat_pump, cooling_agent_type, cooling_agent_powerè fornito. Non fornire se estimate_energyè1 |
wood_pellets_kwh |
numero < float > > = 0 In kWh. Non fornire se estimate_energyè1 |
legno_chips_kwh |
numero < float > > = 0 In kWh. Non fornire se estimate_energyè1 |
cooling_agent_power |
numero < float > > = 0 nel kW |
stima_mobilità necessario |
string Predefinito: "0" Enum : "0" "1" 1se è necessario stimare le emissioni di mobilità. In questo caso, non forniscono average_commuting_distance_km, public_transportation_commute_per_cent, commuted_yearly_bus_km, commuted_yearly_train_km, commuted_yearly_car_km, business_yearly_car_km, business_yearly_public_transportation_km, hotel_nights_amount, flights_amount, car_fuel_gasoline_liters, car_fuel_diesel_liters, car_fuel_natural_gas_kg, car_fuel_biogas_kg, short_flights_amount, medium_flights_amount, long_flights_amount,business_or_first_flights_per_cent |
consider_advanced_commute_inputs |
string Predefinito: "1" Enum : "0" "1" se 0: fornire average_commuting_distance_kmepublic_transportation_commute_per_cent se 1: fornire commuted_yearly_bus_km, commuted_yearly_train_km,commuted_yearly_car_km |
consider_advanced_business_trip_inputs |
string Predefinito: "0" Enum : "0" "1" se 0: fornire business_yearly_car_km, business_yearly_public_transportation_km,hotel_nights_amount se 1: fornire car_fuel_gasoline_liters, car_fuel_diesel_liters, car_fuel_natural_gas_kg,car_fuel_biogas_kg |
consider_advanced_flight_inputs |
string Predefinito: "0" Enum : "0" "1" se 0: fornireflights_amount se 1: fornire short_flights_amount, medium_flights_amount, long_flights_amount,business_or_first_flights_per_cent |
consider_rough_flight_inputs |
string Predefinito: "1" Enum : "0" "1" se 0: fornire short_flights_amount, medium_flights_amount, long_flights_amount,business_or_first_flights_per_cent se 1: fornireflights_amount |
average_commuting_distance_km |
numero < float > A kmsenso unico. Fornisci solo se consider_advanced_commute_inputsè 0. |
public_transportation_commute_per_cent |
numero < float > > = 0 In percentuale, ad esempio 50.3se il valore è 50.3%. Fornisci solo se consider_advanced_commute_inputs è0 |
commuted_yearly_bus_km |
numero < float > fornire solo se consider_advanced_commute_inputs è1 |
commuted_yearly_train_km |
numero < float > fornire solo se consider_advanced_commute_inputsè1 |
commuted_yearly_car_km |
numero < float > fornire solo se consider_advanced_commute_inputsè1 |
business_yearly_car_km |
numero < float > fornire solo se consider_advanced_business_trip_inputsè0 |
business_yearly_public_transportation_km |
numero < float > fornire solo se estimate_mobilityè1 |
hotel_nights_amount |
numero intero fornire solo se estimate_mobilityè1 |
flight_amount |
numero intero fornire solo se consider_rough_flight_inputsè 1 ed consider_advanced_flight_inputsè0 |
car_fuel_gasoline_liters |
numero < float > fornire solo se consider_advanced_business_trip_inputsè1 |
car_fuel_diesel_liters |
numero < float > fornire solo se consider_advanced_business_trip_inputsè1 |
car_fuel_natural_gas_kg |
numero < float > fornire solo se consider_advanced_business_trip_inputsè1 |
car_fuel_biogas_kg |
numero < float > fornire solo se consider_advanced_business_trip_inputsè1 |
short_flights_amount |
numero intero Fino a 3 ore di volo. i voli di andata e ritorno contano come 2 voli fornire solo se consider_advanced_flight_inputsè 1ed consider_rough_flight_inputsè0 |
medium_flights_amount |
numero intero 3-6 ore di volo. i voli di andata e ritorno contano come 2 voli fornire solo se consider_advanced_flight_inputsè 1ed consider_rough_flight_inputsè0 |
long_flights_amount |
numero intero più di 6 ore di volo. i voli di andata e ritorno contano come 2 voli fornire solo se consider_advanced_flight_inputsè 1ed consider_rough_flight_inputsè0 |
business_or_first_flights_per_cent |
numero < float > > = 0 In percentuale, ad esempio 50.3se il valore è 50.3%. Fornisci solo se consider_advanced_commute_inputsè0 |
stima_cibo_e_bevande necessario |
string Predefinito: "0" Enum : "0" "1" |
warm_meal_meat_amount_per_day |
numero intero fornire solo se estimate_food_and_beveragesè0 |
warm_meal_vegetarian_amount_per_day |
numero intero fornire solo se estimate_food_and_beveragesè0 |
spuntini |
numero intero Numero di spuntini al giorno. Fornisci solo se estimate_food_and_beveragesè0 |
soda_liters_per_day |
numero < float > in litri al giorno il consumo di acqua minerale e soda fornisce solo se estimate_food_and_beveragesè0 |
coffee_portions_per_day |
numero intero In tazze. Fornisci solo se estimate_food_and_beveragesè1 |
tea_portions_per_day |
numero intero In tazze. Fornisci solo se estimate_food_and_beveragesè0 |
stima_forniture necessario |
string Predefinito: "0" Enum : "0" "1" |
consider_advanced_supplies_inputs |
string Predefinito: "0" Enum : "0" "1" |
consider_advanced_garbage_inputs |
string Predefinito: "0" Enum : "0" "1" |
paper_kg |
numero < float > fornire solo se estimate_suppliesè0 |
printed_matters_kg |
numero < float > fornire solo se estimate_suppliesè0 |
electronic_devices_amount |
numero < numero intero > Numero di nuovi computer, laptop, monitor, ecc. Acquistati. Fornisci solo se estim_supplies è 1 |
garbage_kg |
numero < float > fornire solo se estimate_suppliesè0 |
paper_recycling_paper_per_cent |
numero < float > fornire solo se consider_advanced_supplies_inputsè1 |
print_matters_recycling_paper_per_cent |
numero < float > fornire solo se consider_advanced_supplies_inputsè1 |
toners_amount |
numero intero fornire solo se consider_advanced_supplies_inputsè1 |
acqua_m3 |
numero < float > fornire solo se consider_advanced_supplies_inputsè1 |
garbage_recycling_kg |
numero < float > fornire solo se consider_advanced_garbage_inputsè1 |
garbage_electronics_kg |
numero < float > fornire solo se consider_advanced_garbage_inputsè1 |
garbage_hazardous_kg |
numero < float > fornire solo se consider_advanced_garbage_inputsè1 |
Codice requisito |
Area |
Requisito funzionale, tecnico, archietturale o infrastrutturale |
Req08 |
Interfaccia |
Fornire all’utente finale, con il supporto di contenuti grafici e testuali, una serie completa di tutte le strategie di Corporate Environmental Responsability finanziare e reputazionali confacenti alle caratteristiche specifiche dell’azienda cliente, in maniera tale da guidare l’utente nella valutazione. |
|
|
|
La progettazione dell’interfaccia utente può essere migliorata con l’implementazione della seguente libreria per la visualizzazione di grafici interattivi: Python Altair.
Si forniscono i seguenti esempi di implementazione interattiva per supportare lo sviluppo:
import altair as alt
from vega_datasets import data
source = data.seattle_weather()
brush = alt.selection(type='interval', encodings=['x'])
bars = alt.Chart().mark_bar().encode(
x='month(date):O',
y='mean(precipitation):Q',
opacity=alt.condition(brush, alt.OpacityValue(1), alt.OpacityValue(0.7)),
).add_selection(
brush
)
line = alt.Chart().mark_rule(color='firebrick').encode(
y='mean(precipitation):Q',
size=alt.SizeValue(3)
).transform_filter(
brush
)
alt.layer(bars, line, data=source)
import altair as alt
from vega_datasets import data
source = data.movies.url
pts = alt.selection(type="single", encodings=['x'])
rect = alt.Chart(data.movies.url).mark_rect().encode(
alt.X('IMDB_Rating:Q', bin=True),
alt.Y('Rotten_Tomatoes_Rating:Q', bin=True),
alt.Color('count()',
scale=alt.Scale(scheme='greenblue'),
legend=alt.Legend(title='Total Records')
)
)
circ = rect.mark_point().encode(
alt.ColorValue('grey'),
alt.Size('count()',
legend=alt.Legend(title='Records in Selection')
)
).transform_filter(
pts
)
bar = alt.Chart(source).mark_bar().encode(
x='Major_Genre:N',
y='count()',
color=alt.condition(pts, alt.ColorValue("steelblue"), alt.ColorValue("grey"))
).properties(
width=550,
height=200
).add_selection(pts)
alt.vconcat(
rect + circ,
bar
).resolve_legend(
color="independent",
size="independent"
)
E’ stato prodotto il seguente mokup per l’interfaccia di supporto alla corporate reputation
E’ stato prodotto il seguente mokup per l’interfaccia di supporto alla corporate enviromental resposability
E’ stato prodotto il seguente mokup per l’interfaccia di supporto alla finanza agevolata:
Codice requisito |
Area |
Requisito funzionale, tecnico, archietturale o infrastrutturale |
Req09 |
Interfaccia |
Fornire una diagnostica finanziaria completa dell’attività dell’azienda cliente permettendo di risalire, anche ad esempio tramite la presentazione a video di grafici descrittivi, in maniera semplice e veloce alle cause che determinano eventuali vulnerabilità di bilancio, rischi di insolvenza o impatti ambientali negativi. |
Sulla base dei requisiti si prevede l’utilizzo della libreria python Bokeh https://bokeh.org/ dal momento che in questo caso l’integrazione tra i diversi grafici può essere fondamentale per far indiviuare correlazioni. La libreria bokeh dispone di una toolbar specifica per l’itnerazione con i grafici.
Si restituisce un esempio di codice con relativo grafico:
from functools import lru_cache |
|
from os.path import dirname, join |
|
|
|
import pandas as pd |
|
|
|
from bokeh.io import curdoc |
|
from bokeh.layouts import column, row |
|
from bokeh.models import ColumnDataSource, PreText, Select |
|
from bokeh.plotting import figure |
|
|
|
DATA_DIR = join(dirname(__file__), 'daily') |
|
|
|
DEFAULT_TICKERS = ['AAPL', 'GOOG', 'INTC', 'BRCM', 'YHOO'] |
|
|
|
def nix(val, lst): |
|
return [x for x in lst if x != val] |
|
|
|
@lru_cache() |
|
def load_ticker(ticker): |
|
fname = join(DATA_DIR, 'table_%s.csv' % ticker.lower()) |
|
data = pd.read_csv(fname, header=None, parse_dates=['date'], |
|
names=['date', 'foo', 'o', 'h', 'l', 'c', 'v']) |
|
data = data.set_index('date') |
|
return pd.DataFrame({ticker: data.c, ticker+'_returns': data.c.diff()}) |
|
|
|
@lru_cache() |
|
def get_data(t1, t2): |
|
df1 = load_ticker(t1) |
|
df2 = load_ticker(t2) |
|
data = pd.concat([df1, df2], axis=1) |
|
data = data.dropna() |
|
data['t1'] = data[t1] |
|
data['t2'] = data[t2] |
|
data['t1_returns'] = data[t1+'_returns'] |
|
data['t2_returns'] = data[t2+'_returns'] |
|
return data |
|
|
|
# set up widgets |
|
|
|
stats = PreText(text='', width=500) |
|
ticker1 = Select(value='AAPL', options=nix('GOOG', DEFAULT_TICKERS)) |
|
ticker2 = Select(value='GOOG', options=nix('AAPL', DEFAULT_TICKERS)) |
|
|
|
# set up plots |
|
|
|
source = ColumnDataSource(data=dict(date=[], t1=[], t2=[], t1_returns=[], t2_returns=[])) |
|
source_static = ColumnDataSource(data=dict(date=[], t1=[], t2=[], t1_returns=[], t2_returns=[])) |
|
tools = 'pan,wheel_zoom,xbox_select,reset' |
|
|
|
corr = figure(plot_width=350, plot_height=350, |
|
tools='pan,wheel_zoom,box_select,reset') |
|
corr.circle('t1_returns', 't2_returns', size=2, source=source, |
|
selection_color="orange", alpha=0.6, nonselection_alpha=0.1, selection_alpha=0.4) |
|
|
|
ts1 = figure(plot_width=900, plot_height=200, tools=tools, x_axis_type='datetime', active_drag="xbox_select") |
|
ts1.line('date', 't1', source=source_static) |
|
ts1.circle('date', 't1', size=1, source=source, color=None, selection_color="orange") |
|
|
|
ts2 = figure(plot_width=900, plot_height=200, tools=tools, x_axis_type='datetime', active_drag="xbox_select") |
|
ts2.x_range = ts1.x_range |
|
ts2.line('date', 't2', source=source_static) |
|
ts2.circle('date', 't2', size=1, source=source, color=None, selection_color="orange") |
|
|
|
# set up callbacks |
|
|
|
def ticker1_change(attrname, old, new): |
|
ticker2.options = nix(new, DEFAULT_TICKERS) |
|
update() |
|
|
|
def ticker2_change(attrname, old, new): |
|
ticker1.options = nix(new, DEFAULT_TICKERS) |
|
update() |
|
|
|
def update(selected=None): |
|
t1, t2 = ticker1.value, ticker2.value |
|
|
|
df = get_data(t1, t2) |
|
data = df[['t1', 't2', 't1_returns', 't2_returns']] |
|
source.data = data |
|
source_static.data = data |
|
|
|
update_stats(df, t1, t2) |
|
|
|
corr.title.text = '%s returns vs. %s returns' % (t1, t2) |
|
ts1.title.text, ts2.title.text = t1, t2 |
|
|
|
def update_stats(data, t1, t2): |
|
stats.text = str(data[[t1, t2, t1+'_returns', t2+'_returns']].describe()) |
|
|
|
ticker1.on_change('value', ticker1_change) |
|
ticker2.on_change('value', ticker2_change) |
|
|
|
def selection_change(attrname, old, new): |
|
t1, t2 = ticker1.value, ticker2.value |
|
data = get_data(t1, t2) |
|
selected = source.selected.indices |
|
if selected: |
|
data = data.iloc[selected, :] |
|
update_stats(data, t1, t2) |
|
|
|
source.selected.on_change('indices', selection_change) |
|
|
|
# set up layout |
|
widgets = column(ticker1, ticker2, stats) |
|
main_row = row(corr, widgets) |
|
series = column(ts1, ts2) |
|
layout = column(main_row, series) |
|
|
|
# initialize |
|
update() |
|
|
|
curdoc().add_root(layout) |
|
curdoc().title = "Stocks"
|
E’ stato quindi predisposto il seguente mokup:
Codice requisito |
Area |
Requisito funzionale, tecnico, archietturale o infrastrutturale |
Req10 |
Interfaccia, Control Room |
Interfacciarsi con un sistema informativo interno di più alto livello da cui ad esempio ricevere le informazioni riguardanti la percentuale di successo delle strategie finanziare e di miglioramento di impatto ambientale suggerite in casi analoghi in passato, e verso cui fornire informazioni riguardanti le elaborazioni effettuate, le scelte degli utenti, il time on page nella navigazione ecc. |
Sulla base dei requisiti si prevede l’utilizzo della libreria python Bokeh https://bokeh.org/ dal momento che in questo caso l’integrazione tra i diversi grafici può essere fondamentale per far indiviuare correlazioni. La libreria bokeh dispone di una toolbar specifica per l’itnerazione con i grafici.
E’ stato quindi predisposto il seguente mokup:
Codice requisito |
Area |
Requisito funzionale, tecnico, archietturale o infrastrutturale |
Req11 |
Interfaccia |
Schede interattive dei bandi |
Si prevede che ogni bando sia presentato con relativa interfaccia di scheda interattiva, con elementi salienti corredo. Un esempio efficace può essere dato da ambienti di visualizzazione documenti interattivi come coda (https://coda.io/).
E’ stato quindi predisposto il seguente mokup:
Codice requisito |
Area |
Requisito funzionale, tecnico, archietturale o infrastrutturale |
Req12 |
Interfaccia |
Calcolo predittivo dei risultati ottenuti dalle iniziative proposte con usabilità migliorata |
Sulla base della libreria bokeh si prevede un intevento sull’interaffaccia già prevista per il supporto alle strategie di finanza agevolata secondo il seguente mockup:
Dove la linea rossa rappresenta il momento attuale e sulla destra vengono restituiti i risultati previsti per i mesi successivi.
A.2.2 Miglioramento dei parametri del modulo software di sourcing da banche dati, riconoscimento documenti e selezione delle informazioni
Requisiti del modulo software di sourcing da banche dati, riconoscimento documenti e selezione delle informazioni
Si riassumono di seguito i requisiti dell’improvement della progettazione di competenza dell’attività:
Area |
Requisito funzionale, tecnico, archietturale o infrastrutturale |
|
Req01 |
Data sorucing |
guidare la raccolta delle informazioni necessarie al cliente; |
Req02 |
Data sourcing; |
reperire sulla base delle informazioni raccolte i relativi documenti richiesti da apposite banche dati di enti pubblici o privati; |
Req03 |
Data sourcing; Data processing |
Misurazione del Carbon Footprint |
Req04 |
Data processing |
riconoscere e selezionare le informazioni necessarie da tali documenti, uniformare la formattazione dei dati ed elaborarli secondo schemi prestabiliti per ricavare parametri utili; |
Req05 |
Algoritmo, Engine, Intelligenza artificiale |
Permettere che il funzionamento degli algoritmi si adatti in modo intelligente alle specifiche esigenze imprenditoriali dell’utente finale, ad esempio modulando la selezione dei parametri da elaborare in funzione della tipologia di investimento (ad esempio acquisto di macchinari, formazione, innovazione di prodotto o di processo ecc) o di strategia di miglioramento di impatto ambientale (ad esempio certificazioni come. Global Gap, FSC, Ecolabel, VeganOK) per cui si dimostra interesse. |
Progettazione di dettaglio del modulo software di sourcing da banche dati, riconoscimento documenti e selezione delle informazioni
Codice requisito |
Area |
Requisito funzionale, tecnico, archietturale o infrastrutturale |
Req01 |
Data sorucing |
guidare la raccolta delle informazioni necessarie al cliente; |
Req02 |
Data sourcing; |
reperire sulla base delle informazioni raccolte i relativi documenti richiesti da apposite banche dati di enti pubblici o privati; |
Req03 |
Data sourcing; Data processing |
Misurazione del Carbon Footprint |
La misurazione del carbon footprint può avvenire tramite chiamata API.
Si restituisce un esempio di chiamata con relativa risposta
{
"name": "Acme Inc.",
"country": "CH",
"number_of_employees": 5,
"estimate_energy": "1",
"estimate_mobility": "1",
"estimate_food_and_beverages": "1",
"estimate_supplies": "1"
}
Risposta:
{
"kg": 37975,
"energy_kg": "16435.0",
"mobility_kg": "17125.0",
"food_kg": "1440.0",
"supplies_kg": "2975.0",
"price_in_eur_cents": 0,
"input_params": {
"name": "Acme Inc.",
"country": "CH",
"number_of_employees": 5,
"heated_area": null,
"estimate_energy": "1",
"consider_advanced_energy_inputs": "0",
"power_consumption_kwh": null,
"green_electricity": null,
"oil_liters": null,
"natural_gas_m3": null,
"biogas_m3": null,
"district_heat_kwh": null,
"wood_pellets_kwh": null,
"wood_chips_kwh": null,
"heat_pump": null,
"cooling_agent_type": null,
"cooling_agent_power": null,
"estimate_mobility": "1",
"consider_advanced_commute_inputs": "1",
"consider_advanced_business_trip_inputs": "0",
"consider_advanced_flight_inputs": "0",
"consider_rough_flight_inputs": "1",
"average_commuting_distance_km": null,
"public_transportation_commute_per_cent": null,
"commuted_yearly_bus_km": null,
"commuted_yearly_train_km": null,
"commuted_yearly_car_km": null,
"business_yearly_car_km": null,
"business_yearly_public_transportation_km": null,
"hotel_nights_amount": null,
"flights_amount": null,
"car_fuel_gasoline_liters": null,
"car_fuel_diesel_liters": null,
"car_fuel_natural_gas_kg": null,
"car_fuel_biogas_kg": null,
"short_flights_amount": null,
"medium_flights_amount": null,
"long_flights_amount": null,
"business_or_first_flights_per_cent": null,
"estimate_food_and_beverages": "1",
"warm_meal_meat_amount_per_day": null,
"warm_meal_vegetarian_amount_per_day": null,
"snacks": null,
"soda_liters_per_day": null,
"coffee_portions_per_day": null,
"tea_portions_per_day": null,
"estimate_supplies": "1",
"consider_advanced_supplies_inputs": "0",
"consider_advanced_garbage_inputs": "0",
"paper_kg": null,
"printed_matters_kg": null,
"electronic_devices_amount": null,
"garbage_kg": null,
"paper_recycling_paper_per_cent": null,
"printed_matters_recycling_paper_per_cent": null,
"toners_amount": null,
"water_m3": null,
"garbage_recycling_kg": null,
"garbage_electronics_kg": null,
"garbage_hazardous_kg": null
}
}
A seconda dei dati disponibili, ogni sezione del calcolatore può essere stimata o calcolata in base ai dati forniti. Per alcune sezioni questo viene fatto su una scala ancora più preciso. Ad esempio, se vengono forniti dati sulla mobilità, è possibile stimare le emissioni dei voli sulla base di una quantità complessiva di voli. Se sono disponibili dati precisi sulla durata di questi voli, possono essere forniti per calcolare le emissioni in modo più preciso.
La misurazione della corporate reputation può essere svolta tramite chiamata api su talkwalker.com
L'API di ricerca di Talkwalker ti consente di recuperare fino a 500 risultati ordinati per un determinato periodo di tempo negli ultimi 30 giorni . Inoltre, può essere restituito anche un istogramma del numero di risultati. Si possono ordinare i risultati per ora di pubblicazione, tempo di indicizzazione, coinvolgimento o altre metriche. Una singola query di ricerca può supportare fino a 50 operandi. Per creare query complesse, gli operandi possono essere combinati utilizzando operatori booleani.
I risultati della ricerca possono essere ordinati per coinvolgimento, tempo o altre metriche ed essere limitati a intervalli di valori di attributi specifici (ad esempio restituiscono solo risultati pubblicati in un determinato intervallo di tempo). Quando non vengono applicati filtri speciali, una singola richiesta di ricerca restituirà i risultati di tutti i tipi di media e di tutte le lingue negli ultimi 30 giorni ordinati per coinvolgimento per impostazione predefinita. Non è necessario eseguire una richiesta di ricerca per ogni lingua e tipo di supporto separatamente. Per ottenere un insieme più piccolo di risultati, puoi ottenere solo i risultati con il punteggio più alto o ottenere un set campione casuale.
L'endpoint dei risultati di ricerca dell'API Talkwalker ( https://api.talkwalker.com/api/v1/search/results) viene utilizzato per eseguire ricerche sull'API Talkwalker. (A scopo di test access_token demopuò essere utilizzato. L'impostazione della variabile pretty=truerestituirà risultati formattati)
Si fornisce un esempio di chiamata
curl -XGET 'https://api.talkwalker.com/api/v1/search/results?access_token=demo&q=cats&pretty=true'
e relativa risposta:
{
"status_code" : "0",
"status_message" : "OK",
"request" : "GET /api/v1/search/results?access_token=demo&q=cats&pretty=true",
"pagination" : {
"next" : "GET /api/v1/search/results?access_token=demo&q=cats&pretty=true&offset=10",
"total" : 298138
},
"result_content" : {
"data" : [ {
"data" : {
"url" : "http://example.blogspot.com/cats",
"indexed" : 1417999367498,
"search_indexed" : 1417999504832,
"published" : 1417999319393,
"title" : "Something cats",
"content" : "Welcome to my colorful little island (...)",
"title_snippet" : "Something with cats",
"root_url" : "http://example.blogspot.com/",
"domain_url" : "http://blogspot.com/",
"host_url" : "http://example.blogspot.com/",
"parent_url" : "http://example.blogspot.com/cats",
"lang" : "en",
"porn_level" : 0,
"fluency_level" : 90,
"spam_level" : 20,
"sentiment" : 5,
"source_type" : [ "BLOG", "BLOG_OTHER" ],
"post_type" : [ "TEXT" ],
"tokens_title" : [ "Something", "Something", "Cats", "Cats" ],
"tokens_content" : [ "Bead Hoarder Blog", "Bead Hoarder Blog"],
"tokens_mention" : [ "@yahoo" ],
"tags_internal" : [ "isQuestion" ],
"article_extended_attributes" : {
"num_comments" : 3
},
"source_extended_attributes" : {
"alexa_pageviews" : 0
},
"extra_article_attributes" : {
"world_data" : { }
},
"extra_author_attributes" : {
"world_data" : { },
"id" : "ex:example.blogspot.com-698904645",
"name" : "view my complete profile",
"gender" : "MALE"
},
"extra_source_attributes" : {
"world_data" : {
"continent" : "North America",
"country" : "United States",
"region" : "District of Columbia",
"city" : "Washington, D.C.",
"longitude" : -77.0094185808,
"latitude" : 38.8995493765,
"country_code" : "us"
},
"id" : "ex:example.blogspot.com",
"name" : "http://example.blogspot.com/"
},
"engagement" : 3,
"reach" : 0
}
}, {
"data" : {
"url" : "http://example.wordpress.com/2014/12/06/high-rez-snobbery-715-winter-trend-ice/",
Parametri
parametro |
descrizione |
necessario? |
valore predefinito |
access_token |
Token di accesso API |
necessario |
|
q |
La query da cercare |
necessario |
|
offset |
Numero di risultati da saltare (per la paginazione) |
opzionale |
predefinito: 0 / massimo: 500 |
hpp |
Numero di visite per pagina (per paging) |
opzionale |
predefinito: 10 / massimo: 500 |
sort_by |
Criteri per l'ordinamento dei risultati. |
opzionale |
default: coinvolgimento |
sort_order |
Ordinamento (ascendente o discendente) |
opzionale |
predefinito: desc |
hl |
Attiva o disattiva l'evidenziazione |
opzionale |
predefinito: 1 |
pretty |
Json formattato per il test |
opzionale |
falso |
Per quanto riguarda gli aspetti finanziari si consolida la scelta di utilizzo delle API CERVED l’estrazione del codice ATECO può essere quindi effettuata in modo automatico a partire dalla partita iva:
INPUT (CERVED API) |
OUTPUT (CERVED API) |
Partita IVA (Numero intero) |
Codice ateco (stringa) |
Codice requisito |
Area |
Requisito funzionale, tecnico, archietturale o infrastrutturale |
Req04 |
Data processing |
riconoscere e selezionare le informazioni necessarie da tali documenti, uniformare la formattazione dei dati ed elaborarli secondo schemi prestabiliti per ricavare parametri utili; |
Per il filtering dei risultati si prevedono i seguenti passaggi:
1. Trasformazione dei dati in dataframe tramite libreria pandas.
2. Utilizzo delle utility della libreria pandas per il filtering dei risultati
Si fornisce il seguente esempio
In [96]: df
Out[96]:
A B C D
a 1 4 9 1
b 4 5 0 2
c 5 5 1 0
d 1 3 9 6
In [99]: df[(df.A == 1) & (df.D == 6)]
Out[99]:
A B C D
d 1 3 9 6
In [90]: def mask(df, key, value):
....: return df[df[key] == value]
....:
In [92]: pandas.DataFrame.mask = mask
In [93]: df = pandas.DataFrame(np.random.randint(0, 10, (4,4)), index=list('abcd'), columns=list('ABCD'))
In [95]: df.ix['d','A'] = df.ix['a', 'A']
In [96]: df
Out[96]:
A B C D
a 1 4 9 1
b 4 5 0 2
c 5 5 1 0
d 1 3 9 6
In [97]: df.mask('A', 1)
Out[97]:
A B C D
a 1 4 9 1
d 1 3 9 6
In [98]: df.mask('A', 1).mask('D', 6)
Out[98]:
A B C D
d 1 3 9 6
Si fa riferimento alla documentazione ufficiale per il supporto allo sviluppo:
https://pandas.pydata.org/docs/
Codice requisito |
Area |
Requisito funzionale, tecnico, archietturale o infrastrutturale |
Req05 |
Algoritmo, Engine, Intelligenza artificiale |
Permettere che il funzionamento degli algoritmi si adatti in modo intelligente alle specifiche esigenze imprenditoriali dell’utente finale, ad esempio modulando la selezione dei parametri da elaborare in funzione della tipologia di investimento (ad esempio acquisto di macchinari, formazione, innovazione di prodotto o di processo ecc) o di strategia di miglioramento di impatto ambientale (ad esempio certificazioni come. Global Gap, FSC, Ecolabel, VeganOK) per cui si dimostra interesse. |
Il requisito viene soddisvatto attraverso lo sviluppo di un recommender system. Per Recommendation System si intende un sistema software che ha il compito di prevedere quanto è quantitativamente forte l’interesse di un utente nei confronti di un oggetto, al fine di essere in grado di consigliare l’oggetto che più lo interessa. In parole semplici: un Recommendation System valuta sulla base del comportamento precedente, quanto sia forte l’attrazione che determinati elementi esercitano su di un utente, per poi automaticamente cercare dei elementi simili e potenzialmente ugualmente interessanti. Lo scopo di un Recommender System è fornire all’utente suggerimenti che corrispondano alle sue preferenze. Per raggiungere tale obiettivo, ci sono una serie di proprietà che un Recommender System dovrebbe garantire: la trasparenza, la possibilità di correzione, l’affidabilità, l’efficacia, la capacità di persuasione, l’efficienza, la soddisfazione del cliente, l’ampiezza dei risultati, l’aggiornamento costante, la serendipità, la varietà dei suggerimenti, la robustezza, il rispetto della privacy, la scalabilità.
Adottando come criterio di classificazione di un Recommender System l’origine dei suggerimenti si possono distinguere quattro tipi di RS:
1. Collaborative Based (o Social based). Il RS suggerisce all’utente gli item preferiti dalle persone simili a lui
2. Content Based. Gli item suggeriti dal sistema sono simili a quelli che l’utente ha giudicato positivamente in passato.
3. Economic Factor Based. Il sistema suggerisce gli item che possiedono il miglior rapporto qualità prezzo, in base ai costi oggettivi e alle valutazioni soggettive degli utenti.
4. Hybrid. Nei suggerimenti di questo tipo vi è la compresenza di due o più fattori tra quelli sopracitati (preferenze degli utenti simili, item preferiti dall’utente, rapporto qualità prezzo).
Nel caso del sistem IAFCER si prevede un RS di tipo Hybrid.
I suggerimenti possono essere forniti in base a specifiche richieste dell’utente oppure proposti in automatico. In base al modello di information retrieval utilizzato si distinguono tre tipi di Recommender System:
1. Pull information model. L’utente deve eseguire una query per ricevere il suggerimento, specificando i parametri necessari alla ricerca.
2. Push information model. L’utente riceve i suggerimenti in base alle informazioni contenute nel suo profilo.
3. Hybrid. È una combinazione dei due modelli.
Nel caso del sistem IAFCER si prevede un RS di tipo push. Il profilo dell’azienda arricchito dai dati raccolti fornisce ovvero la base per il RS.
In base alle modalità di generazione dei suggerimenti si possono identificare sei diverse tipologie di Recommender System:
1. User Centered. Il sistema calcola la somiglianza tra un utente e tutti gli altri attraverso una misura di similarità e seleziona i cosiddetti vicini, cioè quegli utenti per i quali il valore della misura di similarità supera una soglia prefissata. Sulla base delle valutazioni dei vicini il RS calcola i rating medi degli item e redige una classifica.
2. Item Based. Il Recommender System calcola la somiglianza tra le preferenze specificate nel profilo dell’utente e le caratteristiche contenute nella descrizione degli item. Gli item che ottengono una misura di similarità sopra una certa soglia vengono proposti all’utente, gli altri vengono scartati.
3. Mining associate rules. Diversamente dai primi due casi, qui ci si affida ad un metodo statistico. Fissata una soglia m, se un oggetto X viene acquistato da n utenti e di questi n utenti almeno m acquistano anche Y, allora esiste una regola XY. In tal caso il RS suggerisce Y agli utenti che sono interessati a X.
4. Demography Based. Il RS classifica l’utente in base ai dati demografici contenuti nel suo profilo. Per una determinata categoria, quindi, identifica le informazioni più rilevanti e su tale base determina i suggerimenti più appropriati. Il sistema, quindi, propone alle persone appartenenti alla stessa categoria i medesimi suggerimenti.
5. Knowledge Based. Un Recommender System può generare i suggerimenti sfruttando le sue informazioni implicite sull’utente. I tre modi possibili sono: la deduzione di preferenze a partire da dati relativi a necessità e desideri dell’utente; l’utilizzo delle esperienze passate dell’utente per determinare le sue valutazioni su item per lui nuovi; la derivazione di inferenze attraverso l’applicazione di strumenti di data mining ai dati sull’utente.
6. Hybrid. Il RS produce i suggerimenti sfruttando due o più strategie tra quelle sopracitate.
Nel caso del sistem IAFCER si prevede un RS di tipo Hybrid.
Si propone un’architettura del tipo:
Si fornisce un esempio di RS basato su filtering collaborativo di diretto supporto allo sviluppo:
# Recommendation System Tutorial - Netflix |
|
# URL: https://towardsai.net/recommendation-system-tutorial |
|
|
|
# Download datasets |
|
!wget https://datasets.towardsai.net/combined_data_4.txt |
|
!wget https://raw.githubusercontent.com/towardsai/tutorials/master/recommendation_system_tutorial/movie_titles.csv |
|
!wget https://raw.githubusercontent.com/towardsai/tutorials/master/recommendation_system_tutorial/new_features.csv |
|
|
|
!pip install scikit-surprise |
|
|
|
from datetime import datetime |
|
import pandas as pd |
|
import numpy as np |
|
import seaborn as sns |
|
import os |
|
import random |
|
import matplotlib |
|
import matplotlib.pyplot as plt |
|
from scipy import sparse |
|
from sklearn.metrics.pairwise import cosine_similarity |
|
from sklearn.metrics import mean_squared_error |
|
|
|
import xgboost as xgb |
|
from surprise import Reader, Dataset |
|
from surprise import BaselineOnly |
|
from surprise import KNNBaseline |
|
from surprise import SVD |
|
from surprise import SVDpp |
|
from surprise.model_selection import GridSearchCV |
|
|
|
def load_data(): |
|
netflix_csv_file = open("netflix_rating.csv", mode = "w") |
|
rating_files = ['combined_data_4.txt'] |
|
for file in rating_files: |
|
with open(file) as f: |
|
for line in f: |
|
line = line.strip() |
|
if line.endswith(":"): |
|
movie_id = line.replace(":", "") |
|
else: |
|
row_data = [] |
|
row_data = [item for item in line.split(",")] |
|
row_data.insert(0, movie_id) |
|
netflix_csv_file.write(",".join(row_data)) |
|
netflix_csv_file.write('\n') |
|
|
|
netflix_csv_file.close() |
|
df = pd.read_csv('netflix_rating.csv', sep=",", names = ["movie_id","customer_id", "rating", "date"]) |
|
return df |
|
|
|
netflix_rating_df = load_data() |
|
netflix_rating_df |
|
netflix_rating_df.head() |
|
|
|
netflix_rating_df.duplicated(["movie_id","customer_id", "rating", "date"]).sum() |
|
|
|
split_value = int(len(netflix_rating_df) * 0.80) |
|
train_data = netflix_rating_df[:split_value] |
|
test_data = netflix_rating_df[split_value:] |
|
|
|
plt.figure(figsize = (12, 8)) |
|
ax = sns.countplot(x="rating", data=train_data) |
|
|
|
ax.set_yticklabels([num for num in ax.get_yticks()]) |
|
|
|
plt.tick_params(labelsize = 15) |
|
plt.title("Count Ratings in train data", fontsize = 20) |
|
plt.xlabel("Ratings", fontsize = 20) |
|
plt.ylabel("Number of Ratings", fontsize = 20) |
|
plt.show() |
|
|
|
def get_user_item_sparse_matrix(df): |
|
sparse_data = sparse.csr_matrix((df.rating, (df.customer_id, df.movie_id))) |
|
return sparse_data |
|
|
|
train_sparse_data = get_user_item_sparse_matrix(train_data) |
|
|
|
test_sparse_data = get_user_item_sparse_matrix(test_data) |
|
|
|
global_average_rating = train_sparse_data.sum()/train_sparse_data.count_nonzero() |
|
print("Global Average Rating: {}".format(global_average_rating)) |
|
|
|
def get_average_rating(sparse_matrix, is_user): |
|
ax = 1 if is_user else 0 |
|
sum_of_ratings = sparse_matrix.sum(axis = ax).A1 |
|
no_of_ratings = (sparse_matrix != 0).sum(axis = ax).A1 |
|
rows, cols = sparse_matrix.shape |
|
average_ratings = {i: sum_of_ratings[i]/no_of_ratings[i] for i in range(rows if is_user else cols) if no_of_ratings[i] != 0} |
|
return average_ratings |
|
|
|
average_rating_user = get_average_rating(train_sparse_data, True) |
|
|
|
avg_rating_movie = get_average_rating(train_sparse_data, False) |
|
|
|
total_users = len(np.unique(netflix_rating_df["customer_id"])) |
|
train_users = len(average_rating_user) |
|
uncommonUsers = total_users - train_users |
|
|
|
print("Total no. of Users = {}".format(total_users)) |
|
print("No. of Users in train data= {}".format(train_users)) |
|
print("No. of Users not present in train data = {}({}%)".format(uncommonUsers, np.round((uncommonUsers/total_users)*100), 2)) |
|
|
|
total_movies = len(np.unique(netflix_rating_df["movie_id"])) |
|
train_movies = len(avg_rating_movie) |
|
uncommonMovies = total_movies - train_movies |
|
|
|
print("Total no. of Movies = {}".format(total_movies)) |
|
print("No. of Movies in train data= {}".format(train_movies)) |
|
print("No. of Movies not present in train data = {}({}%)".format(uncommonMovies, np.round((uncommonMovies/total_movies)*100), 2)) |
|
|
|
def compute_user_similarity(sparse_matrix, limit=100): |
|
row_index, col_index = sparse_matrix.nonzero() |
|
rows = np.unique(row_index) |
|
similar_arr = np.zeros(61700).reshape(617,100) |
|
|
|
for row in rows[:limit]: |
|
sim = cosine_similarity(sparse_matrix.getrow(row), train_sparse_data).ravel() |
|
similar_indices = sim.argsort()[-limit:] |
|
similar = sim[similar_indices] |
|
similar_arr[row] = similar |
|
|
|
return similar_arr |
|
|
|
similar_user_matrix = compute_user_similarity(train_sparse_data, 100) |
|
|
|
similar_user_matrix[0] |
|
|
|
movie_titles_df = pd.read_csv("movie_titles.csv",sep = ",", |
|
header = None, names=['movie_id', 'year_of_release', 'movie_title'], |
|
index_col = "movie_id", encoding = "iso8859_2") |
|
movie_titles_df.head() |
|
|
|
def compute_movie_similarity_count(sparse_matrix, movie_titles_df, movie_id): |
|
similarity = cosine_similarity(sparse_matrix.T, dense_output = False) |
|
no_of_similar_movies = movie_titles_df.loc[movie_id][1], similarity[movie_id].count_nonzero() |
|
return no_of_similar_movies |
|
|
|
similar_movies = compute_movie_similarity_count(train_sparse_data, movie_titles_df, 1775) |
|
print("Similar Movies = {}".format(similar_movies)) |
|
|
|
def get_sample_sparse_matrix(sparse_matrix, no_of_users, no_of_movies): |
|
users, movies, ratings = sparse.find(sparse_matrix) |
|
uniq_users = np.unique(users) |
|
uniq_movies = np.unique(movies) |
|
np.random.seed(15) |
|
user = np.random.choice(uniq_users, no_of_users, replace = False) |
|
movie = np.random.choice(uniq_movies, no_of_movies, replace = True) |
|
mask = np.logical_and(np.isin(users, user), np.isin(movies, movie)) |
|
sparse_matrix = sparse.csr_matrix((ratings[mask], (users[mask], movies[mask])), |
|
shape = (max(user)+1, max(movie)+1)) |
|
return sparse_matrix |
|
|
|
train_sample_sparse_matrix = get_sample_sparse_matrix(train_sparse_data, 400, 40) |
|
|
|
test_sparse_matrix_matrix = get_sample_sparse_matrix(test_sparse_data, 200, 20) |
|
|
|
def create_new_similar_features(sample_sparse_matrix): |
|
global_avg_rating = get_average_rating(sample_sparse_matrix, False) |
|
global_avg_users = get_average_rating(sample_sparse_matrix, True) |
|
global_avg_movies = get_average_rating(sample_sparse_matrix, False) |
|
sample_train_users, sample_train_movies, sample_train_ratings = sparse.find(sample_sparse_matrix) |
|
new_features_csv_file = open("new_features.csv", mode = "w") |
|
|
|
for user, movie, rating in zip(sample_train_users, sample_train_movies, sample_train_ratings): |
|
similar_arr = list() |
|
similar_arr.append(user) |
|
similar_arr.append(movie) |
|
similar_arr.append(sample_sparse_matrix.sum()/sample_sparse_matrix.count_nonzero()) |
|
|
|
similar_users = cosine_similarity(sample_sparse_matrix[user], sample_sparse_matrix).ravel() |
|
indices = np.argsort(-similar_users)[1:] |
|
ratings = sample_sparse_matrix[indices, movie].toarray().ravel() |
|
top_similar_user_ratings = list(ratings[ratings != 0][:5]) |
|
top_similar_user_ratings.extend([global_avg_rating[movie]] * (5 - len(ratings))) |
|
similar_arr.extend(top_similar_user_ratings) |
|
|
|
similar_movies = cosine_similarity(sample_sparse_matrix[:,movie].T, sample_sparse_matrix.T).ravel() |
|
similar_movies_indices = np.argsort(-similar_movies)[1:] |
|
similar_movies_ratings = sample_sparse_matrix[user, similar_movies_indices].toarray().ravel() |
|
top_similar_movie_ratings = list(similar_movies_ratings[similar_movies_ratings != 0][:5]) |
|
top_similar_movie_ratings.extend([global_avg_users[user]] * (5-len(top_similar_movie_ratings))) |
|
similar_arr.extend(top_similar_movie_ratings) |
|
|
|
similar_arr.append(global_avg_users[user]) |
|
similar_arr.append(global_avg_movies[movie]) |
|
similar_arr.append(rating) |
|
|
|
new_features_csv_file.write(",".join(map(str, similar_arr))) |
|
new_features_csv_file.write("\n") |
|
|
|
new_features_csv_file.close() |
|
new_features_df = pd.read_csv('new_features.csv', names = ["user_id", "movie_id", "gloabl_average", "similar_user_rating1", |
|
"similar_user_rating2", "similar_user_rating3", |
|
"similar_user_rating4", "similar_user_rating5", |
|
"similar_movie_rating1", "similar_movie_rating2", |
|
"similar_movie_rating3", "similar_movie_rating4", |
|
"similar_movie_rating5", "user_average", |
|
"movie_average", "rating"]) |
|
return new_features_df |
|
|
|
train_new_similar_features = create_new_similar_features(train_sample_sparse_matrix) |
|
|
|
train_new_similar_features = train_new_similar_features.fillna(0) |
|
train_new_similar_features.head() |
|
|
|
test_new_similar_features = create_new_similar_features(test_sparse_matrix_matrix) |
|
|
|
test_new_similar_features = test_new_similar_features.fillna(0) |
|
test_new_similar_features.head() |
|
|
|
x_train = train_new_similar_features.drop(["user_id", "movie_id", "rating"], axis = 1) |
|
|
|
x_test = test_new_similar_features.drop(["user_id", "movie_id", "rating"], axis = 1) |
|
|
|
y_train = train_new_similar_features["rating"] |
|
|
|
y_test = test_new_similar_features["rating"] |
|
|
|
def error_metrics(y_true, y_pred): |
|
rmse = np.sqrt(mean_squared_error(y_true, y_pred)) |
|
return rmse |
|
|
|
clf = xgb.XGBRegressor(n_estimators = 100, silent = False, n_jobs = 10) |
|
clf.fit(x_train, y_train) |
|
|
|
y_pred_test = clf.predict(x_test) |
|
|
|
rmse_test = error_metrics(y_test, y_pred_test) |
|
print("RMSE = {}".format(rmse_test)) |
|
|
|
def plot_importance(model, clf): |
|
fig = plt.figure(figsize = (8, 6)) |
|
ax = fig.add_axes([0,0,1,1]) |
|
model.plot_importance(clf, ax = ax, height = 0.3) |
|
plt.xlabel("F Score", fontsize = 20) |
|
plt.ylabel("Features", fontsize = 20) |
|
plt.title("Feature Importance", fontsize = 20) |
|
plt.tick_params(labelsize = 15) |
|
|
|
plt.show() |
|
|
|
plot_importance(xgb, clf) |
A.2.3 Miglioramento dei parametri del modulo software di elaborazione dati e data-mining
Requisiti del modulo software di elaborazione dati e data-mining
Si riassumono di seguito i requisiti dell’improvement della progettazione di competenza dell’attività
Codice requisito |
Area |
Requisito funzionale, tecnico, archietturale o infrastrutturale |
Req03 |
Data sourcing; Data processing |
Misurazione del Carbon Footprint |
Req04 |
Data processing |
riconoscere e selezionare le informazioni necessarie da tali documenti, uniformare la formattazione dei dati ed elaborarli secondo schemi prestabiliti per ricavare parametri utili; |
Req05 |
Algoritmo, Engine, Intelligenza artificiale |
Permettere che il funzionamento degli algoritmi si adatti in modo intelligente alle specifiche esigenze imprenditoriali dell’utente finale, ad esempio modulando la selezione dei parametri da elaborare in funzione della tipologia di investimento (ad esempio acquisto di macchinari, formazione, innovazione di prodotto o di processo ecc) o di strategia di miglioramento di impatto ambientale (ad esempio certificazioni come. Global Gap, FSC, Ecolabel, VeganOK) per cui si dimostra interesse. |
Req06 |
Architecture Documentation |
confrontare i parametri dell’azienda cliente con parametri individuati nelle normative e negli atti pubblici inerenti la Corporate Environmental Responsability, la finanza agevolata e la performance reputazionale; |
Progettazione di dettaglio modulo software di elaborazione dati e data-mining
Codice requisito |
Area |
Requisito funzionale, tecnico, archietturale o infrastrutturale |
Req03 |
Data sourcing; Data processing |
Misurazione del Carbon Footprint |
L’inserimento nella progettazione delle API di myclimate permette di sopperire alle necessità di elaborazione dati e data-mining per quanto riguarda la misurazione del Carbon Footprint.
i dati necessari per il calcolo sono già stati affrontati nella sezione precedente
Codice requisito |
Area |
Requisito funzionale, tecnico, archietturale o infrastrutturale |
Req04 |
Data processing |
riconoscere e selezionare le informazioni necessarie da tali documenti, uniformare la formattazione dei dati ed elaborarli secondo schemi prestabiliti per ricavare parametri utili; |
|
|
|
Per riconoscere e selezionare le informazioni necessarie da documenti, uniformare la formattazione dei dati ed elaborarli secondo schemi prestabiliti per ricavare parametri utili, si prevede l’utilizzo di modelli di NER (Named entity recognition) e Text Classification concatenati, con inoltre un merge dei dati con le API individuate, secondo il seguente schema:
All’interno del sistema IAFCER si prevede la seguente architettura:
Codice requisito |
Area |
Requisito funzionale, tecnico, archietturale o infrastrutturale |
Req06 |
Architecture Documentation |
confrontare i parametri dell’azienda cliente con parametri individuati nelle normative e negli atti pubblici inerenti la Corporate Environmental Responsability, la finanza agevolata e la performance reputazionale; |
All’interno del sistema IAFCER si prevede la seguente architettura:
In particolare sono stati individuati i seguenti parametri di interesse dalle API:
FONTE API |
NOME PARAMETRO |
DESCRIZIONE E NOTE PER LA PROGETTAZIONE IAFCER |
CERVED API |
activity_status |
Stato attività del soggetto trovato |
CERVED API |
business_name |
Ragione sociale del soggetto trovato |
CERVED API |
codice_fiscale |
Ragione sociale del Soggetto |
CERVED API |
dati_anagrafici |
DatiAnagraficiPeople |
CERVED API |
denominazione |
denominazione |
CERVED API |
dt_nascita |
Data di nascita del soggetto |
CERVED API |
economic_activity |
Info sull'attività economica (settore) del soggetto trovato |
CERVED API |
ente |
E' un soggetto appartenente alla Pubblica Amministrazione |
CERVED API |
fornitore |
E' un soggetto fornitore della Pubblica Amministrazione |
CERVED API |
head_office |
Valore booleano indicante se il soggetto trovato è sede della società o no |
CERVED API |
id_soggetto |
Data di nascita del soggetto |
CERVED API |
indirizzo |
Codice fiscale del Soggetto |
CERVED API |
legal_form |
Info sulla forma giuridica del soggetto trovato |
CERVED API |
lei_code |
Codice LEI (Legal Entity Identifier) del soggetto trovato |
CERVED API |
operational_flag |
Valore booleano indicante se il soggetto trovato risulta operativo o no |
CERVED API |
partecipata |
E' un soggetto che ha partecipazioni da parte della Pubblica Amministrazione |
CERVED API |
public_administration |
Info sulla relazione tra soggetto e pubblica amministrazione |
MYCLIMATE API |
namerequired |
string |
MYCLIMATE API |
countryrequired |
string |
MYCLIMATE API |
number_of_employeesrequired |
numero < float >
> = 0 |
MYCLIMATE API |
heated_area |
numero < float > > = 0 |
MYCLIMATE API |
estimate_energyrequired |
string |
MYCLIMATE API |
power_consumption_kwh |
numero < float > > = 0 |
MYCLIMATE API |
green_electricity |
booleano |
MYCLIMATE API |
oil_liters |
numero < float > > = 0 |
MYCLIMATE API |
natural_gas_m3 |
numero < float >
> = 0 |
MYCLIMATE API |
biogas_m3 |
numero < float > > = 0 |
MYCLIMATE API |
district_heat_kwh |
numero < float >
> = 0 |
MYCLIMATE API |
heat_pump |
booleano |
MYCLIMATE API |
cooling_agent_type |
string |
MYCLIMATE API |
consider_advanced_energy_inputs |
string |
MYCLIMATE API |
wood_pellets_kwh |
numero < float >
> = 0 |
MYCLIMATE API |
wood_chips_kwh |
numero < float > > = 0 |
MYCLIMATE API |
cooling_agent_power |
numero < float >
> = 0 |
MYCLIMATE API |
estimate_mobilityrequired |
string |
MYCLIMATE API |
consider_advanced_commute_inputs |
string |
MYCLIMATE API |
consider_advanced_business_trip_inputs |
string |
MYCLIMATE API |
consider_advanced_flight_inputs |
string |
MYCLIMATE API |
consider_rough_flight_inputs |
string |
MYCLIMATE API |
average_commuting_distance_km |
numero < float > |
MYCLIMATE API |
public_transportation_commute_per_cent |
numero < float > > = 0 |
MYCLIMATE API |
commuted_yearly_bus_km |
numero < float > |
MYCLIMATE API |
commuted_yearly_train_km |
numero < float > |
MYCLIMATE API |
commuted_yearly_car_km |
numero < float > |
MYCLIMATE API |
business_yearly_car_km |
numero < float > |
MYCLIMATE API |
business_yearly_public_transportation_km |
numero < float > |
MYCLIMATE API |
hotel_nights_amount |
numero intero |
MYCLIMATE API |
flights_amount |
numero intero |
MYCLIMATE API |
car_fuel_gasoline_liters |
numero < float > |
MYCLIMATE API |
car_fuel_diesel_liters |
numero < float > |
MYCLIMATE API |
car_fuel_natural_gas_kg |
numero < float > |
MYCLIMATE API |
car_fuel_biogas_kg |
numero < float > |
MYCLIMATE API |
short_flights_amount |
numero intero |
MYCLIMATE API |
medium_flights_amount |
numero intero |
MYCLIMATE API |
long_flights_amount |
numero intero |
MYCLIMATE API |
business_or_first_flights_per_cent |
numero < float >
> = 0 |
MYCLIMATE API |
estimate_food_and_beveragesrequired |
string |
MYCLIMATE API |
warm_meal_meat_amount_per_day |
numero intero |
MYCLIMATE API |
snacks |
numero intero |
MYCLIMATE API |
soda_liters_per_day |
numero < float > |
MYCLIMATE API |
coffee_portions_per_day |
numero intero |
MYCLIMATE API |
tea_portions_per_day |
numero intero |
MYCLIMATE API |
estimate_suppliesrequired |
string |
MYCLIMATE API |
consider_advanced_supplies_inputs |
string |
MYCLIMATE API |
paper_kg |
numero < float > |
MYCLIMATE API |
printed_matters_kg |
numero < float > |
MYCLIMATE API |
electronic_devices_amount |
numero < numero intero > |
MYCLIMATE API |
garbage_kg |
numero < float > |
MYCLIMATE API |
printed_matters_recycling_paper_per_cent |
numero < float > |
MYCLIMATE API |
toners_amount |
numero intero |
MYCLIMATE API |
garbage_recycling_kg |
numero < float > |
MYCLIMATE API |
garbage_electronics_kg |
numero < float > |
MYCLIMATE API |
garbage_hazardous_kg |
numero < float > |
TALKWALKER API |
published |
Timestamp di pubblicazione (tempo dell'epoca in millisecondi) |
TALKWALKER API |
search_indexed |
Timestamp dell'indicizzazione in Talkwalker (tempo dell'epoca in millisecondi) |
TALKWALKER API |
reach |
La portata di un articolo / post rappresenta il numero di persone che sono state raggiunte da questo articolo / post. |
TALKWALKER API |
engagement |
Il coinvolgimento di un articolo / post è la somma delle azioni compiute da altri su quell'articolo / post. |
TALKWALKER API |
facebook_shares |
Numero di condivisioni Facebook di un articolo |
TALKWALKER API |
facebook_likes |
Numero di Mi piace su Facebook di un articolo |
TALKWALKER API |
twitter_retweets |
Numero di retweet di Twitter di un articolo |
TALKWALKER API |
twitter_shares |
Numero di condivisioni Twitter di un articolo |
TALKWALKER API |
twitter_likes |
Numero di Mi piace su Twitter di un articolo |
TALKWALKER API |
twitter_followers |
Numero di follower su Twitter di una fonte |
TALKWALKER API |
instagram_likes |
Numero di Mi piace su Instagram che ha un articolo |
TALKWALKER API |
youtube_views |
Numero di visualizzazioni su YouTube di un video |
TALKWALKER API |
youtube_likes |
Numero di Mi piace su YouTube di un video |
TALKWALKER API |
youtube_dislikes |
Numero di Non mi piace su YouTube che un video ha |
TALKWALKER API |
comment_count |
Numero di commenti di un articolo |
TALKWALKER API |
language |
Numero di documenti scritti in una lingua |
TALKWALKER API |
gender |
Numero di documenti scritti da un autore di un particolare sesso |
TALKWALKER API |
age |
Numero di documenti scritti da un autore in un gruppo di età predefinito |
TALKWALKER API |
unique_author |
Numero totale di autori diversi |
TALKWALKER API |
hashtag |
Numero di documenti contenenti un determinato hashtag |
TALKWALKER API |
theme_cloud |
Numero di documenti contenenti una parola o un hashtag particolare |
TALKWALKER API |
interest |
Numero di documenti all'interno di un particolare gruppo di interesse |
TALKWALKER API |
occupation |
Numero di documenti all'interno di un particolare gruppo di professioni |
TALKWALKER API |
sentiment |
Numero di documenti con un sentimento particolare |
A.2.4 Miglioramento dei parametri del modulo software interno di apprendimento con algoritmi intelligenti e controllo del sistema
Requisiti del modulo software interno di apprendimento con algoritmi intelligenti e controllo del sistema
Si riassumono di seguito i requisiti dell’improvement della progettazione di competenza dell’attività:
Codice requisito |
Area |
Requisito funzionale, tecnico, archietturale o infrastrutturale |
Req04 |
Data processing |
riconoscere e selezionare le informazioni necessarie da tali documenti, uniformare la formattazione dei dati ed elaborarli secondo schemi prestabiliti per ricavare parametri utili; |
Req05 |
Algoritmo, Engine, Intelligenza artificiale |
Permettere che il funzionamento degli algoritmi si adatti in modo intelligente alle specifiche esigenze imprenditoriali dell’utente finale, ad esempio modulando la selezione dei parametri da elaborare in funzione della tipologia di investimento (ad esempio acquisto di macchinari, formazione, innovazione di prodotto o di processo ecc) o di strategia di miglioramento di impatto ambientale (ad esempio certificazioni come. Global Gap, FSC, Ecolabel, VeganOK) per cui si dimostra interesse. |
Req07 |
Interoperability |
applicare adeguati algoritmi predittivi per supportare l’interpretazione dei dati; |
Progettazione di dettaglio del modulo software interno di apprendimento con algoritmi intelligenti e controllo del sistema
Codice requisito |
Area |
Requisito funzionale, tecnico, archietturale o infrastrutturale |
Req04 |
Data processing |
riconoscere e selezionare le informazioni necessarie da documenti, uniformare la formattazione dei dati ed elaborarli secondo schemi prestabiliti per ricavare parametri utili; |
Per riconoscere e selezionare le informazioni necessarie da documenti, uniformare la formattazione dei dati ed elaborarli secondo schemi prestabiliti per ricavare parametri utili, si prevede l’utilizzo di modelli di NER (Named entity recognition) e Text Classification concatenati, con inoltre un merge dei dati con le API individuate, secondo il seguente schema:
All’interno del sistema IAFCER si prevede la seguente architettura:
Per i modelli NER e Textcat si individua la libreria python Spacy .
Un'entità testuale è un "oggetto del mondo reale" a cui è assegnato un nome, ad esempio una persona, un paese, un prodotto o il titolo di un libro. spaCy può riconoscere vari tipi di entità denominate in un documento, chiedendo una previsione al modello. Poiché i modelli sono statistici e dipendono fortemente dagli esempi su cui sono stati addestrati, non sempre funziona perfettamente e potrebbe essere necessario un po 'di ottimizzazione in seguito, a seconda del caso d'uso.
Si riporta un esempio di codice:
I modelli di classificazione del testo possono essere utilizzati per risolvere un'ampia varietà di problemi. Le differenze in termini di lunghezza del testo, numero di etichette, difficoltà e vincoli di prestazioni di runtime significano che nessun singolo algoritmo funziona bene su tutti i tipi di problemi. Per gestire una più ampia varietà di problemi, l’oggetto spacy textcategorizer consente la configurazione della sua architettura del modello, utilizzando i seguenti argomenti:
NOME |
DESCRIZIONE |
"ensemble" |
Impostazione predefinita: insieme in pila di un modello di borsa di parole e un modello di rete neurale. La rete neurale utilizza una CNN con media pooling e attenzione. Gli argomenti "ngram_size" e "attr" possono essere utilizzati per configurare l'estrazione delle caratteristiche per il modello bag-of-words. |
"simple_cnn" |
Un modello di rete neurale in cui i vettori di token vengono calcolati utilizzando una CNN. I vettori sono mediamente raggruppati e utilizzati come caratteristiche in una rete feed-forward. Questa architettura è solitamente meno accurata dell'insieme, ma funziona più velocemente. |
"bow" |
Un modello ngram "bag-of-words". Questa architettura dovrebbe funzionare molto più velocemente delle altre, ma potrebbe non essere così accurata, soprattutto se i testi sono brevi. Le funzionalità estratte possono essere controllate utilizzando gli argomenti delle parole chiave ngram_sizee attr. Per esempio, ngram_size=3e attr="lower"darebbe caratteristiche unigram, trigram e sui bigrammi in minuscolo. 2, 3 o 4 sono generalmente buone scelte per la dimensione del ngram. |
Si fornisce esempio di codice di riferimento:
Codice requisito |
Area |
Requisito funzionale, tecnico, archietturale o infrastrutturale |
Req05 |
Algoritmo, Engine, Intelligenza artificiale |
Permettere che il funzionamento degli algoritmi si adatti in modo intelligente alle specifiche esigenze imprenditoriali dell’utente finale, ad esempio modulando la selezione dei parametri da elaborare in funzione della tipologia di investimento (ad esempio acquisto di macchinari, formazione, innovazione di prodotto o di processo ecc) o di strategia di miglioramento di impatto ambientale (ad esempio certificazioni come. Global Gap, FSC, Ecolabel, VeganOK) per cui si dimostra interesse. |
Sulla base di (Shuai Zhang, Lina Yao, Aixin Sun, and Yi Tay. 2019. Deep Learning Based Recommender System: A Survey and New Perspectives. ACM Comput. Surv. 52, 1, Article 5 (February 2019), 38 pages. DOI:https://doi.org/10.1145/3285029) gli algoritmi di intelligenza artificiale per il RS possono essere i seguenti:
1. I-AutoRec e U-AutoRec (www'15)
2. CDAE (WSDM'16)
3. NeuMF (WWW'17)
4. CML (WWW'17)
5. LRML (WWW'18) (versione DRAFT)
6. NFM (SIGIR'17)
7. NNMF (arxiv)
8. PRME (IJCAI 2015)
9. CASER (WSDM 2018)
10. AttRec (AAAI 2019 RecNLP)
I modelli compresi coprono tre principali scenari di raccomandazione: previsione della valutazione, raccomandazione top-N (cioè, classificazione degli articoli) e raccomandazione sequenziale.
I modelli si trovano codificati in python al seguente URL https://github.com/cheungdaven/DeepRec e possono essere implementati per individuare il più efficace nel caso applicativo di IAFCER
A titolo di riferimento riportiamo l’implementazione dell’algoritmo di reccomending system ( Rendle, Steffen, et al. "BPR: Bayesian personalized ranking from implicit feedback “Proceedings of the twenty-fifth conference on uncertainty in artificial intelligence. AUAI Press, 2009.)
import time
import tensorflow as tf
from tensorflow.keras import Input, Model
from tensorflow.keras.layers import Dense, Lambda
from utils.evaluation.RankingMetrics import *
__author__ = "Shuai Zhang"
__copyright__ = "Copyright 2018, The DeepRec Project"
__license__ = "GPL"
__version__ = "1.0.0"
__maintainer__ = "Shuai Zhang"
__email__ = "cheungdaven@gmail.com"
__status__ = "Development"
class EmbeddingLookup(tf.keras.layers.Layer):
def __init__(self, input_embedding, **kwargs):
super(EmbeddingLookup, self).__init__(**kwargs)
self.input_embedding = input_embedding
# def build(self, input_shape):
# self.embeddings = self.add_weight(
# shape=(self.input_dim, self.output_dim),
# initializer='random_normal',
# dtype='float32')
def call(self, inputs):
return tf.nn.embedding_lookup(self.input_embedding, inputs)
class BPRMF(object):
def __init__(self, num_user, num_item, learning_rate=0.001, reg_rate=0.1, epoch=500, batch_size=1024,
verbose=False, t=5, display_step=1000):
self.num_user = num_user
self.num_item = num_item
self.learning_rate = learning_rate
self.reg_rate = reg_rate
self.epochs = epoch
self.batch_size = batch_size
self.verbose = verbose
self.T = t
self.display_step = display_step
self.user_id = Input(shape=(1,), dtype=tf.int32, name='user_id')
self.item_id = Input(shape=(1,), dtype=tf.int32, name='item_id')
self.neg_item_id = Input(shape=(1,), dtype=tf.int32, name='neg_item_id')
self.P = None
self.Q = None
self.pred_y = None
self.pred_y_neg = None
self.loss = None
self.loss_estimator = tf.keras.metrics.Mean(name='train_loss')
self.optimizer = tf.keras.optimizers.Adam(learning_rate=self.learning_rate)
self.test_data = None
self.user = None
self.item = None
self.neg_items = None
self.test_users = None
self.num_training = None
self.total_batch = None
print("You are running BPRMF.")
def build_network(self, num_factor=30):
self.P = tf.Variable(tf.random.normal([self.num_user, num_factor], stddev=0.01))
self.Q = tf.Variable(tf.random.normal([self.num_item, num_factor], stddev=0.01))
# user_id = tf.squeeze(self.user_id)
# item_id = tf.squeeze(self.item_id)
# neg_item_id = tf.squeeze(self.neg_item_id)
user_id = Lambda(lambda x: tf.squeeze(x))(self.user_id)
item_id = Lambda(lambda x: tf.squeeze(x))(self.item_id)
neg_item_id = Lambda(lambda x: tf.squeeze(x))(self.neg_item_id)
user_latent_factor = EmbeddingLookup(self.P)(user_id)
item_latent_factor = EmbeddingLookup(self.Q)(item_id)
neg_item_latent_factor = EmbeddingLookup(self.Q)(neg_item_id)
# user_latent_factor = tf.nn.embedding_lookup(self.P, user_id)
# item_latent_factor = tf.nn.embedding_lookup(self.Q, item_id)
# neg_item_latent_factor = tf.nn.embedding_lookup(self.Q, neg_item_id)
pred_y = tf.reduce_sum(tf.multiply(user_latent_factor, item_latent_factor), 1)
pred_y_neg = tf.reduce_sum(tf.multiply(user_latent_factor, neg_item_latent_factor), 1)
self.model = Model(inputs=[self.user_id, self.item_id, self.neg_item_id],
outputs=[pred_y, pred_y_neg])
# self.optimizer = tf.train.AdamOptimizer(learning_rate=self.learning_rate).minimize(self.loss)
def prepare_data(self, train_data, test_data):
"""
You must prepare the data before train and test the model
:param train_data:
:param test_data:
:return:
"""
t = train_data.tocoo()
self.user = t.row.reshape(-1)
self.item = t.col.reshape(-1)
self.num_training = len(self.item)
self.test_data = test_data
self.total_batch = int(self.num_training / self.batch_size)
self.neg_items = self._get_neg_items(train_data.tocsr())
self.test_users = set([u for u in self.test_data.keys() if len(self.test_data[u]) > 0])
print("data preparation finished.")
@tf.function
def train_op(self, batch_user, batch_item, batch_item_neg):
with tf.GradientTape() as tape:
pred_y, pred_y_neg = self.model([batch_item, batch_user, batch_item_neg])
loss = - tf.reduce_sum(
tf.math.log(tf.sigmoid(pred_y - pred_y_neg))) + \
self.reg_rate * (tf.nn.l2_loss(self.P) + tf.nn.l2_loss(self.Q))
gradients_of_model = tape.gradient(loss, self.model.trainable_variables)
self.optimizer.apply_gradients(zip(gradients_of_model, self.model.trainable_variables))
self.loss_estimator(loss)
def train(self):
idxs = np.random.permutation(self.num_training) # shuffled ordering
user_random = list(self.user[idxs])
item_random = list(self.item[idxs])
item_random_neg = []
for u in user_random:
neg_i = self.neg_items[u]
s = np.random.randint(len(neg_i))
item_random_neg.append(neg_i[s])
# train
for i in range(self.total_batch):
start_time = time.time()
batch_user = np.array(user_random[i * self.batch_size:(i + 1) * self.batch_size])
batch_item = item_random[i * self.batch_size:(i + 1) * self.batch_size]
batch_item_neg = item_random_neg[i * self.batch_size:(i + 1) * self.batch_size]
np_batch_user = np.expand_dims(np.array(batch_user), -1)
np_batch_item = np.expand_dims(np.array(batch_item), -1)
np_batch_item_neg = np.expand_dims(np.array(batch_item_neg), -1)
self.train_op(np_batch_user, np_batch_item, np_batch_item_neg)
if i % self.display_step == 0:
if self.verbose:
print("Index: %04d; cost= %.9f" % (i + 1, self.loss_estimator.result()))
print("one iteration: %s seconds." % (time.time() - start_time))
def test(self):
evaluate(self)
def execute(self, train_data, test_data):
self.prepare_data(train_data, test_data)
for epoch in range(self.epochs):
self.train()
if epoch % self.T == 0:
print("Epoch: %04d; " % epoch, end='')
self.test()
def save(self, path):
saver = tf.train.Saver()
saver.save(self.sess, path)
def predict(self, user_id, item_id):
user_id = tf.expand_dims(tf.convert_to_tensor(user_id), -1)
item_id = tf.expand_dims(tf.convert_to_tensor(item_id), -1)
dummy_neg_id = tf.zeros(item_id.shape, tf.int32)
pred_y, pred_y_neg = self.model([user_id, item_id, dummy_neg_id])
return pred_y.numpy()
def _get_neg_items(self, data):
all_items = set(np.arange(self.num_item))
neg_items = {}
for u in range(self.num_user):
neg_items[u] = list(all_items - set(data.getrow(u).nonzero()[1]))
return neg_items
Codice requisito |
Area |
Requisito funzionale, tecnico, archietturale o infrastrutturale |
Req07 |
Interoperability |
applicare adeguati algoritmi predittivi per supportare l’interpretazione dei dati; |
Per quanto riguarda l’uso di algoritmi predittivi per l’interpretazione dei dati si definisce il seguente caso d’uso:
1. Il sistema registra le percentuali di successo degli utenti che selezionano soluzioni di finanza agevolata/Corporate Enviromental Responsability/ Corporate reputation.
2. Il sistema registra un set di metadati che associano il cliente alla soluzione selezionata.
3. L’utente seleziona una soluzione di finanza agevolata/Corporate Enviromental Responsability/ Corporate reputation.
4. Sulla base dei dati registrati su utenti simili il sistema utilizza un algoritmo predittivo per predire la percentuale di successo possibile dell’utente con la soluzione selezionata.