Temă Seminar 3

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

Script:

import pymongo
import pandas as pd
from pprint import pprint
conn = pymongo.MongoClient("mongodb://37.120.249.57:27017/")
db = conn["daune_leasing"]
collection = db["clienti_leasing"]
projection = {"_id": 0,
"NUME_CLIENT": 1,
"SUMA_SOLICITATA": 1,
"SUMA_DEPOZIT": 1,
"FIDELITATE": 1,
"VARSTA":1
}
sort = [("SUMA_SOLICITATA", 1)]

cursor = collection.find({"VARSTA": {'$gt' : 35},

"SUMA_SOLICITATA": {'$gt': 15000}}, projection=projection, sort=sort)

df = pd.DataFrame.from_dict(list(cursor))
cursor.close()
pprint (df)
df.loc[(df['SUMA_SOLICITATA'] < df['SUMA_DEPOZIT']),
'FIDELITATE']=df.loc[(df['SUMA_SOLICITATA'] < df['SUMA_DEPOZIT']),
'FIDELITATE' == 5]
pprint(df)
df.to_csv('clienti_leasing.csv')

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).
Reprezentați grafic gradul de îndatorare pe fiecare profesie.

Script:

import pymongo
import pandas as pd
import matplotlib.pyplot as plt
from pprint import pprint
conn = pymongo.MongoClient("mongodb://37.120.249.57:27017/")
db = conn["daune_leasing"]
collection = db["clienti_leasing"]
pipeline=[{'$group' : {
"_id" : "$PROFESIA",
"VENIT_ANUAL": { '$sum': "$VENIT_ANUAL" },
"SUMA_SOLICITATA": { '$sum': "$SUMA_SOLICITATA" },
"SUMA_DEPOZIT": { '$sum': "$SUMA_DEPOZIT" }
}},
{ '$sort': {"_id": 1}}]
cursor = collection.aggregate(pipeline)

df = pd.DataFrame.from_dict(list(cursor))
cursor.close()
df['GRAD_INDATORARE'] =df["SUMA_SOLICITATA"] / (df["VENIT_ANUAL"]
+df[ "SUMA_DEPOZIT"])*100
pprint (df)

df.plot.bar(x='_id', y='GRAD_INDATORARE', rot=0)

plt.xlabel('PROFESIA')
plt.ylabel('GRAD_INDATORARE')
plt.show()

3. Încărcați într-un df marca, modelul, valoarea totală și numărul de daune pe

fiecare model și marcă fabricate între 2010 și 2012. Afișați numărul de
autoturisme pentru care valoarea totală depășește 30.000$. Reprezentați grafic
modelele care au înregistrat mai mult de 100 de daune.

Script:

import pymongo
import pandas as pd
import matplotlib.pyplot as plt
from pprint import pprint
conn = pymongo.MongoClient("mongodb://37.120.249.57:27017/")
db = conn["daune_leasing"]
collection = db["clienti_daune"]
pipeline=[{'$group' : {
"_id" : {'MARCA':"$MARCA", 'MODEL':"$MODEL"},
"DAUNA": { '$count': "$DAUNA" },
"VALOARE_DAUNA": { '$sum': "$VALOARE_DAUNA" }
}},
{ '$sort': {"_id": 1}}]

cursor = collection.find({"AN_FABRICATIE": {'$lt': 2010, '$gt': 2012},

"VALOARE_DAUNA": {'$gt': 30000}}, pipeline=pipeline, sort=sort)
df = pd.DataFrame.from_dict(list(cursor))
cursor.close()
pprint (df)

df_plot=df.loc[(df['DAUNA']>100)]
df_plot.plot.bar(x='_id', y='DAUNA', rot=0)
plt.xlabel('MODEL')
plt.ylabel('DAUNA')
plt.show()

5. Grupați autoturismele cu daune în 4-6 clustere în funcție de marcă, anul

fabricației, producător, valoarea totală a daunei pe fiecare marcă, costul materialelor
(componentelor) și al manoperei.

Script:

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

conn = pymongo.MongoClient("mongodb://37.120.249.57:27017/")
db = conn["daune_leasing"]
collection = db["clienti_daune"]
pipeline=[{'$group' : {
"_id" : "$MARCA",
"PRODUCATOR" : 1,
"AN_FABRICATIE" : 1,
"PRET_MANOPERA" : 1,
"PRET_TOTAL" : 1,
"VALOARE_DAUNA": { '$sum': "$VALOARE_DAUNA" }
}},
{ '$sort': {"_id": 1}}]
cursor = collection.aggregate(pipeline)

df = pd.DataFrame.from_dict(list(cursor))
cursor.close()
df = pd.concat([df.drop(['_id'],axis=1), df['_id'].apply(pd.Series)],axis=1)
df.dropna(inplace=True, axis=0)

labelEncoder = LabelEncoder()
df['PRODUCATOR']= labelEncoder.fit_transform(df['PRODUCATOR'].astype(str))
df['MARCA'] = labelEncoder.fit_transform(df['MARCA'].astype(str))

df.fillna(df.mean(), inplace=True)
df = stats.zscore(df)

kmeans = KMeans(n_clusters=6).fit(df)
y = kmeans.predict(df)

df['CLUSTER'] = y
print (df.groupby(['CLUSTER']).mean())
df.to_csv('CLIENTI_CLUSTERIZATI.csv', encoding='utf-8', index=False)
plt.scatter(df['VALOARE_DAUNA'], y, cmap='rainbow')
plt.show ()

df.groupby(['CLUSTER']).size().plot(kind='pie', autopct='%.1f%%')
plt.axis('equal')
plt.show()

6. Pe baza exemplului 9 din seminar, utilizați rețelele neuronale artificiale

pentru estimarea sumei solicitate de către clienți.

Script:

from sklearn import linear_model

from sklearn.neural_network import MLPRegressor
import pymongo
import pandas as pd
from sklearn.preprocessing import LabelEncoder, StandardScaler
from sklearn.feature_selection import SelectKBest, f_regression
import seaborn as sns
import matplotlib as plt
from sklearn.metrics import mean_squared_error, r2_score

conn = pymongo.MongoClient("mongodb://37.120.249.57:27017/")
db = conn["daune_leasing"]
collection = db["clienti_leasing"]
pipeline=[{'$group' : {
"_id" : { 'NUME_CLIENT': "$NUME_CLIENT",'PROFESIA':"$PROFESIA",
'VARSTA':"$VARSTA"},
"SUMA_SOLICITATA": { '$sum': "$SUMA_SOLICITATA" }
}},
{ '$sort': {"_id": 1}}]
cursor = collection.aggregate(pipeline)

df = pd.DataFrame.from_dict(list(cursor))
cursor.close()

df = pd.concat([df.drop(['_id'],axis=1), df['_id'].apply(pd.Series)],axis=1)

df_x=df.copy()
df_x=df_x.drop("SUMA_SOLICITATA", axis=1)
labelEncoder = LabelEncoder()
df_x['NUME_CLIENT']= labelEncoder.fit_transform(df_x['NUME_CLIENT'].astype(str))
df_x['PROFESIA'] = labelEncoder.fit_transform(df_x['PROFESIA'].astype(str))
df_x['VARSTA'] = labelEncoder.fit_transform(df_x['VARSTA'].astype(str))

df_x.fillna(df.mean(), inplace=True)
df_y=df['SUMA_SOLICITATA']

k_features = 4
selector = SelectKBest(f_regression, k = k_features)

X_new = selector.fit(df_x, df_y)

names = df_x.columns.values[selector.get_support()]
scores = selector.scores_[selector.get_support()]
names_scores = list(zip(names, scores))
ns_df = pd.DataFrame(data = names_scores, columns=['Feat_names', 'F_Scores'])

ns_df_sorted = ns_df.sort_values(['F_Scores', 'Feat_names'], ascending = [False, True])

print(ns_df_sorted)

df_x = selector.fit_transform(df_x, df_y)

scaler = StandardScaler()
scaler.fit(df_x)
df_x = scaler.transform(df_x)

lm = linear_model.LinearRegression()
model = lm.fit(df_x,df_y)

y_pred= lm.predict(df_x)

df['SUMA_SOLICITATA_LR'] = y_pred

print("Coeficientul R pentru setul de training REGRESIE: ",lm.score(df_x,df_y))

Rcoeff = r2_score(df['SUMA_SOLICITATA'], df['SUMA_SOLICITATA_LR'])
print("R REGRESIE: ", Rcoeff)

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

hidden_layer_sizes=(50,50), max_iter=1000,learning_rate='adaptive',
random_state=1,learning_rate_init=.01)
mlp.fit(df_x, df_y)

y_pred= mlp.predict(df_x)

df['SUMA_SOLICITATA_ANN'] = y_pred

print("Coeficientul R pentru setul de training ANN: ", mlp.score(df_x, df_y))

Rcoeff = r2_score(df['SUMA_SOLICITATA'], df['SUMA_SOLICITATA_ANN'])
print("R ANN: ", Rcoeff)