S3 - Analiza Datelor Organizate in MongoDB Utilizand Python

1.
Lucrul cu pachetele în Python

Instalarea pachetelor se face cu utilitarul pip apelabil din command prompt. Sintaxa este
următoarea:
pip install nume_pachet
Pentru exemplele din seminar vom instala următoarele pachete:
- pymongo – pentru conexiunea cu MongoDB;
- pandas – pentru analiza datelor;
- matplotlib – pentru afișarea graficelor (pe PC din ASE este deja instalat);
- scikit-learn – pentru utilizarea algoritmilor de regresie și clusterizare (pe PC din ASE este
deja instalat);
- numpy – pentru calcul numeric, utilizat în cadrul scikit (pe PC din ASE este deja instalat).
Deschidem command prompt în Windows și setăm calea către directorul unde se află instalat
Python și utilitarul pip. Implicit calea este:
C:\Users\Nume_utilizator\AppData\Local\Programs\Python\Python37\Scripts.
Instalăm toate pachetele specificate mai sus (pymongo, pandas, scikit-learn).
După instalare, deschidem PyCharm în care realizăm un nou proiect (File-New Project).
Denumim proiectul SeminarABD. În cadrul proiectului, realizăm un nou fișier de tip Python
(click dr. pe numele proiectului->New ->Python File). Denumim fișierul Ex1. Implicit acesta
se va deschide pentru editare.
Pentru testarea mediului de lucru, inițializăm o listă scurtă (x) formată din 5 numere intregi:
x=[1,2,3,4,5]
print (x)
Rulăm fișierul prin selectarea acestuia din Project Explorer din partea stângă (click dr. pe
Ex1.py și Run).
1
Pentru o introducere în Python, lucru cu variabile, instrucțiuni și exemple parcurgeți
seminarul S0 - Introducere in Python.
2. Pachetul pymongo
Interacțiunea dintre Python și MongoDB este posibilă prin intermediul pachetului pymongo
care conține metode pentru accesul la bazele de date și colecțiile stocate în MongoDb.
Pașii pentru accesul la documentele din MongoDB sunt următorii:
1. Se importă pachetul pymongo în Python:
import pymongo
2. Se precizează conexiunea la serverul MongoDB:

conn = pymongo.MongoClient("mongodb://IP:27017/")
3. Opțional se pot afișa bazele de date disponibile:

print(conn.list_database_names())
4. Se precizează baza de date care se va accesa:

db = conn["NUME_DATABASE"]
5. Opțional se pot afișa colecțiile de date disponibile:

print(db.list_collection_names())
6. Se precizează colecția care urmează să fie accesată:

collection = db["NUME_COLECTIE"]
7. Se formează parametrii pentru regăsirea datelor și returnarea acestora într-un cursor:

projection={"_id":0,
"CAMP1":1,
"CAMP2":1,
……… }
2
sort=[("CAMP1", 1)]
8. Se returnează datele într-o variabilă de tip cursor:

cursor=collection.find({},projection=projection, sort=sort)
9. Datele din cursor se pot încărca într-o listă de documente MongoDB sub forma de
dicționare:
set_clienti=list(cursor)
O altă variantă: se poate inițializa o listă goală și la fiecare iterație a cursorului se adaugă un
document în listă. Avantajul ar fi că se pot face prelucrări suplimentare pe fiecare record din
cursor înaintea încărcării în listă, de exemplu nu încărcăm documentele pentru care valoarea
daunei este null:
set_clienti=[]
for r in cursor:
if str(r['VALOARE_DAUNA'])!='nan':
set_clienti.append(r)
10. Putem să afisăm lista de documente:

print (set_clienti)
11. Închidem cursorul:

cursor.close()
Datele sunt încărcate în listă și pot fi prelucrate ulterior.
Exemplul 1. Conectarea la MongoDB și afișarea documentelor din colecția clienti_daune.

Se returnează doar câmpurile: MARCA, MODEL, REGIUNEPRODUCATOR ,
TARAPRODUCATOR și VALOARE_DAUNA.
Documentele vor fi ordonate în funcție de MARCA.
Nu se vor încărca documentele cu valori lipsă pentru daune.
import pymongo
conn = pymongo.MongoClient("mongodb://37.120.249.57:27017/")
print(conn.list_database_names())
db = conn["daune_leasing"]
print(db.list_collection_names())
collection = db["clienti_daune"]
"TARAPRODUCATOR":1,
"REGIUNEPRODUCATOR":1,
"MARCA":1,
"MODEL":1,
"VALOARE_DAUNA":1
}
sort=[("MARCA", 1)]
#lista set_clienti este o lista de dictionare care va contine campurile
selectate
set_clienti=[]
3
for r in cursor:
if str(r['VALOARE_DAUNA'])!='nan':
set_clienti.append(r)
print (set_clienti)
cursor.close()
O variantă mai elegantă de afișare o oferă pachetul pprint și metoda pprint. Vom adăuga la
început importul acesteia:
from pprint import pprint
La final, afișăm lista set_clienti cu pprint (înlocuim print (set_clienti)):

pprint (set_clienti)
Exemplul 2. Modificăm exemplul de mai sus astfel încât să fie încărcate toare
documentele, deci lista va fi încărcată cu set_clienti=list(cursor).
Calculăm valoarea totală a daunelor pentru o marcă auto introdusă de utilizator de la
tastatură (cu metoda input)
import pymongo
"TARAPRODUCATOR":1,
"REGIUNEPRODUCATOR":1,
"MARCA":1,
"MODEL":1,
"VALOARE_DAUNA":1
}
sort=[("MARCA", 1)]
set_clienti=list(cursor)
pprint (set_clienti)
cursor.close()
#prelucrarea datelor din lista
v_marca = input("Introduceti marca: ");
print ("Marca selectata este : ", v_marca)
total_daune=0
for r in set_clienti:
if str(r['MARCA']).find(v_marca.upper())!=-1:
total_daune=total_daune+r['VALOARE_DAUNA']
print ("Valoarea totala a daunelor pentru marca", v_marca, " este: ",
total_daune)
Exemplul 3. Să se numere frecvența de apariție a cuvintelor din câmpul DAUNA.

Se vor afișa cuvintele și frecvența de apariție în ordine descrescătoare.
Introduceți o condiție pentru eliminarea cuvintelor uzuale ('the', 'and', 'to', 'a',
'in', 'not', 'of')
import pymongo
projection = {"_id": 0,
4
"DAUNA": 1,
"MARCA": 1,
"MODEL": 1,
"VALOARE_DAUNA": 1
}
sort = [("MARCA", 1)]
cursor = collection.find({}, projection=projection, sort=sort)
set_clienti = list(cursor)
cursor.close()
lista_cuvinte=[]
for dauna in set_clienti:
lista_cuvinte=lista_cuvinte +
str(str(dauna['DAUNA']).lower()).split()
print(lista_cuvinte)
# numaram cuvintele si le adaugam intr-un dictionar
#initial dictionarul este gol si va fi completat cu cuvinte
dictionar = {}
for cuvant in lista_cuvinte:
if cuvant not in dictionar:
dictionar[cuvant] = 1
else:
dictionar[cuvant] += 1
#formam lista cuvintelor si a frecventei de aparitie sortata descrescator
aparitie = []
for key, value in dictionar.items():
if key not in ('the', 'and', 'to', 'a', 'in', 'not', 'of'):
aparitie.append((value, key))
aparitie.sort(reverse=True)
print(aparitie)
Exemplul 4. Să se modifice exemplul de mai sus astfel încât să se afișeze cuvintele cele
mai frecvente pentru o anumită marca auto:
import pymongo
"DAUNA": 1,
"MARCA": 1,
"MODEL": 1,
"VALOARE_DAUNA": 1
}
set_clienti = list(cursor)
cursor.close()
v_marca = input("Introduceti marca: ");
lista_cuvinte=[]
for dauna in set_clienti:
if str(dauna['MARCA']).find(v_marca.upper()) != -1:
lista_cuvinte=lista_cuvinte +
str(str(dauna['DAUNA']).lower()).split()
print(lista_cuvinte)
# numaram cuvintele si le adaugam intr-un dictionar
#initial dictionarul este gol si va fi completat cu cuvinte
dictionar = {}
for cuvant in lista_cuvinte:
if cuvant not in dictionar:
dictionar[cuvant] = 1
5
else:
dictionar[cuvant] += 1
#formam lista cuvintelor si a frecventei de aparitie sortata descrescator
aparitie = []
for key, value in dictionar.items():
if key not in ('the', 'and', 'to', 'a', 'in', 'not', 'of'):
aparitie.append((value, key))
aparitie.sort(reverse=True)
print(aparitie)
Exemple în pandas și MongoDB:

Exemplul 5. Majorați cu 10% pretul manoperei pentru autoturismele fabricate inainte de
2010 și care au componenta BATTERY defectă.
import pymongo
import pandas as pd
"AN_FABRICATIE": 1,
"MARCA": 1,
"COMPONENTA": 1,
"PRET_MANOPERA": 1
}
#incarcam in dataframe inregistrarile din cursor
df = pd.DataFrame.from_dict(list(cursor))
cursor.close()
pprint (df.loc[(df['AN_FABRICATIE'] < 2010) & (df['COMPONENTA']
=='BATTERY'), 'PRET_MANOPERA'])
df.loc[(df['AN_FABRICATIE'] < 2010) & (df['COMPONENTA'] =='BATTERY'),
'PRET_MANOPERA']=df.loc[(df['AN_FABRICATIE'] < 2010) & (df['COMPONENTA']
=='BATTERY'), 'PRET_MANOPERA']*1.10
pprint(df.loc[(df['AN_FABRICATIE'] < 2010) & (df['COMPONENTA']
=='BATTERY'), 'PRET_MANOPERA'])
df.to_csv('clienti_daune_mod.csv')
Modificați exemplul de mai sus astfel încât condiția de regăsire a datelor să fie inclusă în
clauza find({}) utilizată la încărcarea datelor din MongoDB.
În acest caz, setul de date încărcat în DataFrame-ul din pandas este redus și nu mai este
necesară localizarea datelor cu df.loc.
Fișierul excel salvat va conține doar autoturismele selectate.
import pymongo
import pandas as pd
"AN_FABRICATIE": 1,
"MARCA": 1,
"COMPONENTA": 1,
"PRET_MANOPERA": 1
}
6
cursor = collection.find({"COMPONENTA": "BATTERY",
"AN_FABRICATIE": {'$lt': 2010}}, projection=projection,
sort=sort)
cursor.close()
pprint (df)
df['PRET_MANOPERA']=df['PRET_MANOPERA']*1.10
pprint(df)
df.to_csv('clienti_daune_mod.csv')
Exemplul 6. Folosind agregările din MongoDB încărcați într-un DataFrame marca

autoturismelor, valoarea totală a daunelor și pretul manoperei pe fiecare marcă.
Introduceți o nouă coloană în df denumită PROCENT_MANOPERA în care să calculați
ponderea manoperei din valoarea totală a daunelor pe fiecare marcă. Ordonați setul de date
în ordinea descrescătoare a acestui procent și salvați datele într-un fișier .csv
import pandas as pd
pipeline=[{'$group' : {
"_id" : "$MARCA",
"VALOARE_MANOPERA": { '$sum': "$PRET_MANOPERA" },
"VALOARE_DAUNA": { '$sum': "$VALOARE_DAUNA" }
}},
{ '$sort': {"_id": 1}}]
cursor = collection.aggregate(pipeline)
cursor.close()
df['PROCENT_MANOPERA'] =df['VALOARE_MANOPERA'] / df['VALOARE_DAUNA']*100
pprint (df)
Exerciții:
Pe baza colecției din MongoDB CLIENTI_LEASING rezolvați următoarele cerințe:
Exercițiul 1. Încărcați într-un df numele, suma solicitată, suma din depozite și fidelitatea
clienților cu vârsta > 35 de ani care au solicitat un credit mai mare de 15.000$. Verificați în
df dacă suma din depozit este mai mare decât suma solicitată și pentru acești clienți
modificați fidelitatea în 5. Salvați setul de date într-un fișier .csv (clienti_leasing.csv).
Exercițiul 2. Încărcați într-un df profesia, venitul anual, suma din depozite și suma solicitată
pe fiecare profesie. În df adăugați o nouă coloană pentru a calcula gradul de îndatorare pe
fiecare profesie (suma_solicitata/(venit_anual+suma_depozit)*100).
4. Reprezentare grafică cu pachetul matplotlib

Exemplu 7. Reprezentare grafică cu bare.
Pe baza exemplului 5 de mai sus să se reprezinte mărcile și procentul manoperei doar dacă
acesta este mai mare decât 45%
import pymongo
7
import pandas as pd
import matplotlib.pyplot as plt
pipeline=[{'$group' : {
"_id" : "$MARCA",
"VALOARE_MANOPERA": { '$sum': "$PRET_MANOPERA" },
"VALOARE_DAUNA": { '$sum': "$VALOARE_DAUNA" }
}},
{ '$sort': {"_id": 1}}]
cursor = collection.aggregate(pipeline)
cursor.close()
df['PROCENT_MANOPERA'] =df['VALOARE_MANOPERA'] / df['VALOARE_DAUNA']*100
df=df.sort_values(by='PROCENT_MANOPERA')
#extragem subsetul cu procentul >45%
df_plot=df.loc[(df['PROCENT_MANOPERA']>45)]
df_plot.plot.bar(x='_id', y='PROCENT_MANOPERA', rot=0)
plt.xlabel('MARCA')
plt.ylabel('PROCENT_MANOPERA')
plt.show()
Exercițiu: Pe baza exemplului 6 de mai sus, reprezentați grafic gradul de îndatorare pe fiecare
profesie.
5. Tehnici de Machine Learning utilizate Python – pachetul scikit-learn

https://scikit-learn.org/stable/
5.1. Clusterizarea este implementată în clasa kmeans.
Se stabilește numărul dorit de clustere:
8
kmeans = KMeans(n_clusters=n, random_state=0).fit(data_set)
Clusterele sunt obținute prin:
y = kmeans.labels_
sau:
y=kmeans.fit_predict(data_set)
Data setul poate fi direct un DataFrame sau un array de tip numpy (similar cu o matrice).
Exemplu 8. Să se clusterizeze clienții în funcție de următoarele atribute: profesia, sex, venit
anual, valoarea creditelor, vârsta, suma din depozite, fidelitatea, starea civilă și suma
solicitată. Se vor obține 6 clustere similare cu prescoringul actual.
Comparați gruparea cliențior pe cele 6 clustere cu prescoringul inițial.
Analizați grafic repartiția clienților pe clustere în funcția de alte atribute precum: suma
solicitată, vârsta, venitul anual.
Coloanele: profesia, starea civilă, sex se vor transforma cu metoda LabelEncoder() în

valori numerice înainte de clusterizare.
Setul de date de intrare se poate standardiza folosind pachetul stats și metoda zscore.
import pymongo
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.preprocessing import LabelEncoder
from sklearn.cluster import KMeans
from scipy import stats
collection = db["clienti_leasing"]
"PROFESIA":1,
"SEX":1,
"VENIT_ANUAL_RON":1,
"VAL_CREDITE_RON":1,
"VARSTA":1,
"SUMA_DEPOZIT":1,
"FIDELITATE":1,
"STARE_CIVILA":1,
"SUMA_SOLICITATA":1,
"PRESCORING":1
}
cursor = collection.find({}, projection=projection)
cursor.close()
#utilizam un nou df pentru transformarea setului initial in vederea

clusterizarii
df_std=df.copy()
df_std=df_std.drop("PRESCORING", axis=1)
#transformare coloane non-numerice in numerice
labelEncoder = LabelEncoder()
df_std['PROFESIA']=
labelEncoder.fit_transform(df_std['PROFESIA'].astype(str))
df_std['SEX'] = labelEncoder.fit_transform(df_std['SEX'].astype(str))
df_std['STARE_CIVILA'] =
9
labelEncoder.fit_transform(df_std['STARE_CIVILA'].astype(str))
#inlocuire NaN
df_std.fillna(df.mean(), inplace=True)
#optional: analiza ELBOW pt determinarea nr optim de clustere

# wcss = []
# for i in range (1,20):
# kmeans = KMeans(n_clusters = i, init='k-means++', random_state=0)
# kmeans.fit(df)
# wcss.append(kmeans.inertia_)
# plt.plot(range(1,20),wcss)
# plt.title('Elbow Method')
# plt.show()
#Standardizarea valorilor de intrare prin metode zscore

df_std = stats.zscore(df_std)
#clusterizarea
kmeans = KMeans(n_clusters=6, random_state=0).fit(df_std)
y = kmeans.labels_ #sau y=kmeans.fit_predict(df_std)
#Adaugam clusterul in setul initial de date

df['CLUSTER'] = y
print (df.groupby(['CLUSTER']).mean())
df.to_csv('CLIENTI_CLUSTERIZATI.csv', encoding='utf-8', index=False)
plt.scatter(df['SUMA_SOLICITATA'], y, cmap='rainbow')
plt.show ()
plt.scatter(kmeans.cluster_centers_[:,0] ,kmeans.cluster_centers_[:,1],
color='black')
plt.show()
5.2. Regresia liniară este implementată în pachetul scikit-learn prin clasa LinearRegression:
lm = linear_model.LinearRegression()
Pentru aplicarea modelului utiliăm metoda fit(x,y):
model = lm.fit(df_x,df_y)
Metoda predict(x) permite obținerea valorilor estimate:

y_pred= lm.predict(df_x)
Exemplu 9. Să se estimeze suma solicitată de către clienți în funcție de următoarele
atribute: profesia, sex, venit anual, valoarea creditelor, varsta, prescoringul obtinut, suma
din depozite, fidelitatea și starea civilă.
Coloanele: profesia, stare civila, sex se vor transforma cu metoda LabelEncoder() in valori
numerice.
Setul de date de intrare se poate standardiza folosind pachetul stats și metoda zscore.
from sklearn import linear_model
import pymongo
import pandas as pd
10
"PROFESIA":1,
"SEX":1,
"VARSTA":1,
"PRESCORING":1,
"SUMA_DEPOZIT":1,
"FIDELITATE":1,
"STARE_CIVILA":1,
"SUMA_SOLICITATA":1
}
cursor.close()
df['PROFESIA']= labelEncoder.fit_transform(df['PROFESIA'].astype(str))
df['SEX'] = labelEncoder.fit_transform(df['SEX'].astype(str))
df['STARE_CIVILA'] =
labelEncoder.fit_transform(df['STARE_CIVILA'].astype(str))
#inlocuire NaN
df.fillna(df.mean(), inplace=True)
#formam seturile x si y (target)

df_x=df.copy()
df_x=df_x.drop("SUMA_SOLICITATA", axis=1)
df_y=df['SUMA_SOLICITATA']
#apelam modelul de regresie
lm = linear_model.LinearRegression()
model = lm.fit(df_x,df_y)
#obtinem predictia
y_pred= lm.predict(df_x)
#Adaugam coloana in setul initial de date

df['SUMA_PRED'] = y_pred
df.to_csv('CLIENTI_PREDICTIE.csv', encoding='utf-8', index=False)

#coeficientul R:
print(lm.score(df_x,df_y))
5.3. Rețelele neuronale sunt implementate în pachetul scikit-learn în clasele MLPClassifier

și MLPRegressor
(https://scikit-learn.org/stable/modules/neural_networks_supervised.html#tips-on-practical-
use )
Clasele implementează modelul rețelelor neuronale de tip Multi-Layer Perceptron (MLP),
adică rețele cu mai multe straturi de neuroni.
Clasa MLPClassifier este utilizată pentru clasificări, iar clasa MLPRegressor pentru predicții,
similară cu regresia.
11
Ambele clase au următoarele metode comune:
Metoda Explicații
fit(X, Y) Realizarea antrenarea rețelei neuronale în
funcție de inputul X și outputul Y
predict(X) Pe baza rețelei antrenate cu metoda fit() se
obține predicția pentru setul de date X
predict_proba(X) Returnează probabilitățile predicției. Doar
pentru MLPClassifier
score(X, y[, sample_weight]) Determină coeficientul de corelație dintre X
și y.
Parametrii rețelei neuronale se transmit în momentul inițializării unui obiect de tip MLP, cei
mai utilizați fiind:
Parametru Explicații
hidden_layer_sizes Numărul de neuroni pe fiecare strat. De
exemplu: hidden_layer_sizes=20,10
inițializează rețeua cu 2 straturi ascunse,
primul strat având 20 de neuroni, iar al
doilea 10 neuroni
activation : {‘identity’, ‘logistic’, ‘tanh’, Stabilește funcția de activare
‘relu’}, default ‘relu’
Unde:
 ‘identity’, f(x) = x
 ‘logistic’, f(x) = 1 / (1 + exp(-x)).
 ‘tanh’, hyperbolic tan, f(x) = tanh(x).
 ‘relu’, f(x) = max(0, x)
solver : {‘lbfgs’, ‘sgd’, ‘adam’}, default Metoda de antrenare a rețelei
‘adam’
Unde:
 ‘lbfgs’ implementează metode de tip
quasi-Newton.
 ‘sgd’ implementează metoda
stochastic gradient descent.
 ‘adam’ implementează o metodă
bazată pe stochastic gradient
learning_rate : {‘constant’, ‘invscaling’, Stabilește rata de învățare, doar pentru
‘adaptive’}, default ‘constant’ metoda sgd
learning_rate_init : double, optional,

default 0.001
max_iter : int, optional, default 200 Numărul maxim de iterații pentru etapa de
învățare
tol : float, optional, default 1e-4 Toleranța acceptată
Recomandări: datele de intrare (inputul rețelei) se normalizează utilizând metodele din clasa
StandardScaler:
from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
12
scaler.fit(X_train)
X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)
Exemplu 10. Să se clasifice clienții în funcție de următoarele atribute: profesia, sex, venit
anual, valoarea creditelor, varsta, prescoringul obtinut, suma din depozite, fidelitatea, suma
solicitată și starea civilă. Se va estima probabilitatea de contractare a acestora.
Coloanele: profesia, varsta, sex se vor transforma cu metoda LabelEncoder() in valori
numerice.
Setul de date de intrare se standardizează folosind metodele din clasa StandardScaler.
from sklearn.neural_network import MLPClassifier
import pymongo
import pandas as pd
"PROFESIA":1,
"SEX":1,
"VARSTA":1,
"PRESCORING":1,
"SUMA_DEPOZIT":1,
"FIDELITATE":1,
"STARE_CIVILA":1,
"SUMA_SOLICITATA":1,
"PROBABILITATE_CONTRACTARE_N":1
}
cursor.close()
#inlocuire NaN
#formam setul de input si output
df_x=df.copy()
df_x=df_x.drop("PROBABILITATE_CONTRACTARE_N", axis=1)
df_y=df['PROBABILITATE_CONTRACTARE_N']
#Normalizarea valorilor
scaler.fit(df_x)
df_x = scaler.transform(df_x)
# impartim seturile initiale de date in train/test

X_train, X_test = df_x[:12000], df_x[12000:]
y_train, y_test = df_y[:12000].astype(float), df_y[12000:].astype(float)
13
mlp = MLPClassifier(solver='lbfgs', activation='relu',alpha=1e-5,
hidden_layer_sizes=(40,10),
max_iter=100,random_state=1,learning_rate_init=.1)
mlp.fit(X_train, y_train)
#obtinem predictia
y_pred= mlp.predict(df_x)
df['ESTIMARE'] = y_pred
df.to_csv('CLIENTI_PREDICTIE_ANN.csv', encoding='utf-8', index=False)
#afisam coeficiantul de corelatie atat pentru setul de train cat si
pentru cel de test
print("Coeficientul R pentru setul de training: ", mlp.score(X_train,
y_train))
print("Coeficientul R pentru setul de test: ", mlp.score(X_test, y_test))
Testați și alte valori pentru parametrii rețelei neuronale: nr de iterații, funcția de activare, nr
de neuroni și observați modificările coeficienților R.
Exemplu 11. Modificați exemplul de mai sus astfel încât să estimați suma solicitată
utilizând modelul MLPRegressor.
from sklearn.neural_network import MLPRegressor
import pymongo
import pandas as pd
"PROFESIA":1,
"SEX":1,
"VARSTA":1,
"PRESCORING":1,
"SUMA_DEPOZIT":1,
"FIDELITATE":1,
"STARE_CIVILA":1,
"SUMA_SOLICITATA":1
}
cursor.close()
#inlocuire NaN
#formam setul de input si output
df_x=df.copy()
df_x=df_x.drop("SUMA_SOLICITATA", axis=1)
df_y=df['SUMA_SOLICITATA']
14
#Normalizarea valorilor
scaler.fit(df_x)
df_x = scaler.transform(df_x)
# impartim seturile initiale de date in train/test
X_train, X_test = df_x[:12000], df_x[12000:]
y_train, y_test = df_y[:12000].astype(float), df_y[12000:].astype(float)
mlp = MLPRegressor(solver='lbfgs', activation='relu',alpha=1e-5,

hidden_layer_sizes=(50,50),
max_iter=100,random_state=1,learning_rate_init=.01)
mlp.fit(X_train, y_train)
#obtinem predictia
y_pred= mlp.predict(df_x)
df['ESTIMARE'] = y_pred
df.to_csv('CLIENTI_PREDICTIE_ANN.csv', encoding='utf-8', index=False)
#afisam coeficiantul de corelatie atat pentru setul de train cat si
pentru cel de test
print("Coeficientul R pentru setul de training: ", mlp.score(X_train,
y_train))
print("Coeficientul R pentru setul de test: ", mlp.score(X_test, y_test))
Îmbunătățiți performanța predicției modificând parametrii rețelei.
Comparați estimările obținute cu ANN cu cele ale regresiei liniare.
Explorați și alte modele din pachetul scikit-learn disponibile pe adresa: https://scikit-
learn.org/stable/
Referințe
https://pandas.pydata.org/pandas-docs/version/0.21/comparison_with_sql.html
https://www.shanelynn.ie/python-pandas-read_csv-load-data-from-csv-files/
https://www.shanelynn.ie/select-pandas-dataframe-rows-and-columns-using-iloc-loc-and-ix/
https://pandas.pydata.org/pandas-docs/version/0.21/api.html#id2
https://matplotlib.org/gallery/index.html
https://www.datascience.com/blog/k-means-clustering
15

S3 - Analiza Datelor Organizate in MongoDB Utilizand Python

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

S3 - Analiza Datelor Organizate in MongoDB Utilizand Python

Încărcat de

Drepturi de autor:

Formate disponibile

1.

Lucrul cu pachetele în Python

2. Se precizează conexiunea la serverul MongoDB:

3. Opțional se pot afișa bazele de date disponibile:

4. Se precizează baza de date care se va accesa:

5. Opțional se pot afișa colecțiile de date disponibile:

6. Se precizează colecția care urmează să fie accesată:

7. Se formează parametrii pentru regăsirea datelor și returnarea acestora într-un cursor:

8. Se returnează datele într-o variabilă de tip cursor:

10. Putem să afisăm lista de documente:

11. Închidem cursorul:

Datele sunt încărcate în listă și pot fi prelucrate ulterior.

Exemplul 1. Conectarea la MongoDB și afișarea documentelor din colecția clienti_daune.

La final, afișăm lista set_clienti cu pprint (înlocuim print (set_clienti)):

Exemplul 3. Să se numere frecvența de apariție a cuvintelor din câmpul DAUNA.

Exemple în pandas și MongoDB:

Exemplul 6. Folosind agregările din MongoDB încărcați într-un DataFrame marca

4. Reprezentare grafică cu pachetul matplotlib

5. Tehnici de Machine Learning utilizate Python – pachetul scikit-learn

Coloanele: profesia, starea civilă, sex se vor transforma cu metoda LabelEncoder() în

#utilizam un nou df pentru transformarea setului initial in vederea

#optional: analiza ELBOW pt determinarea nr optim de clustere

#Standardizarea valorilor de intrare prin metode zscore

#Adaugam clusterul in setul initial de date

Metoda predict(x) permite obținerea valorilor estimate:

#formam seturile x si y (target)

#Adaugam coloana in setul initial de date

df.to_csv('CLIENTI_PREDICTIE.csv', encoding='utf-8', index=False)

5.3. Rețelele neuronale sunt implementate în pachetul scikit-learn în clasele MLPClassifier

learning_rate_init : double, optional,

# impartim seturile initiale de date in train/test

mlp = MLPRegressor(solver='lbfgs', activation='relu',alpha=1e-5,

S-ar putea să vă placă și