Curs 6: No Iuni de Statistică Ț

Curs 6
Noțiuni de Statistică
Statistica
Studiul fenomenelor si parametrilor variabili
Obiectiv principal : studiul datelor obtinute pe baza unei (sau mai

multor) caracteristici variabile.
Anumite tendinte de evolutie pot capata caracter de regularitate.

Statistica este cea care pune în evidenta aceste regularitati sau legi,
care sunt valabile numai la modul general, ca tendinta, nu neaparat la
fiecare individ în parte.
Statistica cuprinde multitudinea de procedee pentru analiza, interpretarea,

reprezentarea datelor si luarea deciziilor pe baza datelor pe care le
culegem din realitate.
Pentru o abordare stiintifica corecta trebuie respectate standardele privind

colectarea datelor, alegerea esantionului reprezentativ si folosirea unor
metode statistice adecvate.
Tipuri de date
Analiza statistica a unei populatii se face dupa una sau mai multe variabile
Variabile (date): multimea de valori pe care o caracteristica le poate lua

pentru fiecare element al unei populatii statistice.
Date cantitative (măsurabile )

discrete - iau valori numere intregi
continue - pot lua o infinitate de valori
O variabila continua poate fi transformata in una discreta prin "grupare in
Clase" (Ex: varsta sub 18 ani / varsta peste 18 ani)
Date calitative (nemăsurabile)
nominale - sunt grupate in categorii ce nu pot fi ordonate, dar li
se pot atribui etichete (Ex: culoarea parului A-blonzi, B-bruneti, C-roşcaţi
ordinale - datele sunt grupate in categorii ce pot fi ordonate dupa un
anumit criteriu (Ex: varsta: sugar, copil mic, elev, adolescent, adult,
bătrân)
Date binare: variabile calitative ce au numai doua categorii
Colectarea datelor
Analiza datelor – 4 pasi :
 colectarea
 pregatirea(wrangling)
 explorarea
 informația obținuta/ concluziile
Diferite surse de colectare a datelor:
API - colectăm date cu cereri HTTP
Baze de date (cu SQL sau alt limbaj)
Site-urile web publice/guvernamentale( Yahoo! Finance etc)
Web scraping - extrag date din website HTML-ul (exemplu de pachete

Python: selenium, requests , scrapy și beautifulsoup )
Pregătirea datelor
Vrem să adăugăm/eliminăm din setul de date inițial, să reformata ți, să

combinați cu alte date sau să modificați datele într-un fel.
Pregătirea datelor este procesul de introducere a acestora într-un format

care poate fi folosit pentru analiză.
Erori umane: datele sunt înregistrate/colectate incorect (New York City ,

NYC , și nyc ).
Eroari de computer: nu s-au înregistrat date sau date lipsă.
Valori neașteptate: cineva a decis să folosească ? pentru o valoare lipsă
într-o coloană numerică
Informații incomplete: un sondaj, nu toată lumea răspunde la intrebări,
vom avea date lipsă, dar nu din cauza computerului sau eroare umana.
Formatul datelor: datele formatate necorespunzător pentru analiză
Definiții
Populatie statistica: o multime de elemente (indivizi) cu anumite insusiri

comune.
Datele sunt denumite eșantioane (samples) care au fost observate dintr-o

populație. (și sunt un subset al populației).
Statistică descriptivă - căutăm să descriem eșantionul.
Statistică inferenţială (predictivă) - căutăm să inferăm/deducem ceva

despre populație cum ar fi distribuția de bază.
Definiții
Statistica descriptiva: se ocupa cu culegerea datelor si determinarea unor

caracteristici numerice sintetice ale datelor obtinute.
Se limiteaza la descrierea si analiza unei multimi de date (esantion) fara a
trage concluzii asupra multimii din care provine esantionul respectiv.
Statistica predictivă: se ocupa cu obtinerea de concluzii asupra unei

populatii (numar foarte mare) pornind de la un esantion (numar restrans).
Ex.: din testarea unui vaccin pe un lot de voluntari se trag concluzii care
trebuie sa fie valabile pentru intreaga populatie.
Eșantionarea / Sampling
Eșantionul(sample) trebuie să fie un eșantion aleator (random sample)

reprezentativ pentru populație – fără bias.
caracter aleator:
indivizii din eşantion sunt selectaţi aleator;
fiecare membru al populaţiei are o şansă cunoscută, dar posibil ne-
egală de a fi inclus în eşantion.
caracter independent:
un eşantion nu trebuie să afecteze sau să fie afectat de alte eşantioane
selectate din cadrul populaţiei ţintă, sau a altor populaţii.
Metode de obtinere a esantioanelor:
A. esantionarea randomizata - elementele sunt selectate aleator din

populatia statistica, fiecare element avand aceeasi probabilitate de a fi
selectat.
In practica se folosesc functii ce genereza numere aleatoare dintr-o
mulţime de numere (identifica in mod unic fiecare element al populatiei
statistice). Numarul de numere generate aleator este egal cu dimensiunea
esantionului
B. esantionarea sistematica - este selectat fiecare al k-lea element din

populatia statistică.
Numarul k se obţine prin impartirea volumului populatiei statistice la
volumul esantionului (nu se foloseste daca in populatia statistica apar
periodicitati!)
C. esantionarea stratificata (bootstapping ) se realizeaza în doua etape:

I) se imparte populatia statistica in mai multe subgrupe relevante
(straturi);
II) se extrag aleatoriu elemente din straturi (metoda A sau B).
D. esantionarea cluster se realizeaza în doua etape:

I) se imparte populaţia statistica in grupe de dimensiuni egale (clusteri);
II) se extrag aleatoriu elemente din clusteri (metoda A sau B).
Tendinte Centrale - Measures of center
Distribuția datelor- locul în care se concentrează majoritatea datelor
Media - măsura valorii centrale a setului de date în jurul căruia

fluctuează datele
Media eșx antionului xx (se pronuntă X-bar) si estimatorul mediei

populației μ (litera grecească mu).
Proprietăți:
Media aritmetica este influentata de valorile extreme
Exemplu: (0+1+1+2+9)/5 Atenție la outliers!

Suma diferentelor dintre valorile individuale ale esantionului si medie
este totdeauna zero!
Median –se calculează luând valoarea din mijloc dintr-un set de date
ordonat.
Proprietati:
medianul nu este afectat de valorile extreme
medianul poate fi nereprezentativ pentru distributie daca valorile
individuale nu se grupeaza in jurul valorii centrale!
Medianul este:
- termenul al (n+1)/2-lea → daca n este impar
- media dintre termenii n/2 si n/2+1 → daca n este par
Median - a 50% valoare a datelor - 50% dintre valori sunt mai mari decât
medianul și 50% sunt mai mici decât medianul - 2nd cuartile (Q2)
Measures of center
Mode - valoarea ce are cea mai mare frecventa in setul de date.
O folosim pentru a descrie date categorice sau pentru forma distribu ției
pentru date continue.
Distribuții bimodale sau multimodale - distribuții cu două sau mai multe

valori cele mai frecvente.
Indicatori de localizare - valori care împart o distribuţie în grupuri egale
fiecare conţinând acelaşi procent din totalul datelor.
Cuartilele împart datele în patru (25%, 50%, 75% și 100%). Sunt 3:

Primul cuartil (Q1) sau cuartil inferior
valoare mai mare (sau egala) decăt 25% din date
Al doilea cuartil (Q2) sau cuartil median
valoarea mediană (50% din date).
Al treilea cuartil (Q3) sau cuartil superior
valoare mai mare (sau egală) decât 75% din date
Decilele împart o distribuţie în zece părţi egale. Sunt 9:

D5 = 5/10=1/2=median
Percentilele împart o distribuție în 100 părți egale. Sunt 99.

Deviația cuartilă(DQ)/ Interquartile range(IQR)- răspândirea datelor în

jurul median-ului
Măsoară dispersia datelor aflate in zona de mijloc a distribuţiei:
IQR = (Q3-Q1)/2
Mod de calcul:
- se ordonează datele
- se calculează:
valoarea mediana a jumătăţii superioare (Q3=UQ: upper cuartile)
valoarea mediana a jumătăţii inferioare (Q1=LQ: lower cuartile)
Coeficientul de dispersie cuartil (CDC)/ quartile coefficient of
dispersion(QCD)- măsură a centrului median
QCD Se calculează împărțind intervalul semi-quartil (jumătate din IQR) la

midhinge (punctul de mijloc între prima și a treia quartile):
Proprietăți:

QCD este independent de unitatile de masura

QCD se foloseste pentru compararea variabilitatii relative a două seturi
de date
Coeficientul de dispersie cuartil (CDC)/ quartile coefficient of
dispersion(QCD)- măsură a centrului median
QCD Se calculează împărțind intervalul semi-quartil (jumătate din IQR) la

midhinge (punctul de mijloc între prima și a treia quartile):
Proprietăți:

QCD este independent de unitatile de masura

QCD se foloseste pentru compararea variabilitatii relative a două seturi
de date
Am văzut multe exemple de statistici descriptive pe care le putem folosi
pentru a rezuma datele prin centru
Tukey plot - Measures of center
Liniile orizontale se extind spre minim si maxim.
Tot ceea ce e in afara acestor limite sunt outliers.
Histograma - date discrete si continue
Histograma - distribuția în frecvență a datelor
Cum se calculează:
trebuie definit setul de categorii ("bins") in care sa fie grupate valorile
se adaugă bare cu înălțimi diferite reprezentand numărul de valori pe care
le avem în fiecare bin
Tendinte de variabilitate - Measures of spread
Cum sunt dispersate datele - cum se încadrează valorile datelor în jurul

valorii centrale si cât de departe sunt unele de altele.
Cum este distribuția noastră, cât de subțire (dispersie îngustă) sau largă
(foarte răspândită)
Măsura împraștierii (dispersiei) setului de date:
- ofera informații privind extinderea datelor
- este utila în stabilirea reprezentativitatii masurilor de centralitate
-are rol în estimarea parametrilor statistici și în inferența (predicția)

statistică
Domeniul de dispersie (DD) / Range
Distanța dintre cea mai mare valoare (maximă) și cea mai mică valoare
(minimă).
range=max(X) – min(X)
Dezavantaje:
Nu ne dă informația despre împrăștierea în jurul valorii centrale.
Se bazeaza doar pe valorile extreme.

Varianța - cât de departe sunt împrăștiate datele față de valoarea lor
medie.
Varianța populatiei σ 2 (sigma-squared) și varianța eșantionului s 2 .
Unitatea de măsură este egală cu pătratul unității de măsură a valorilor

setului de date.
Corectia Bessel – o estimare unbias a variantei populatiei – cand calculăm

varianța eșantionului, împărțim la n - 1 în loc de n pentru a tine cont de
utilizarea mediei esantionului xx in loc de media populatiei
https://en.wikipedia.org/wiki/Bessel%27s_correction
Dacă volumul eșantionului "n" este mare (n-1 ≈ n):
Tendințe de variabilitate -Measures of spread
Deviația standard - reprezinta "distanta euclidiana" a valorilor fata de

media aritmetică; estimarea uniformității valorilor
Deviatia standard a populatiei reprezentată cu σ si deviatia standard a

esantionului cu s.
Este rădăcina pătrată a varianței, oferindu-ne o măsură în aceleași unități

ca și datele noastre.
Coeficientul de variatie (CV) - o măsură relativă a dispersiei datelor.
CV- este raportul dintre deviația standard și medie
Proprietăți:

CV este independent de unitatile de masura

CV se foloseste pentru compararea variabilitatii relative a două seturi de
date
 CV intervine în studiul omogenității unor populații:
CV <10% populatie omogena

10% < CV < 20% populatie relativ omogena
20% < CV < 30% populatie relativ eterogena
30% < CV populatie eterogena
Asimetria – Skewness - date continue
Abaterea de la aspectul simetric al distributiei de frecventa.
= 0 distributie simetrica
> 0 distributie cu coada spre dreapta
< 0 distributie cu coada spre stanga
Boltirea – Kurtosis - date continue
Aplatizarea/inaltimea unei distributii in raport cu o distributie normala.
= 0 distributie normala
> 0 distributie mai inalta decat cea normala
< 0 distributie mai joasa
Statistica inferentiala
Dacă dorim să ştim cum arată evoluţia în timp a unei anumite

valori, trebuie determinata probabilitatea de apariţie a acelei valori
printre toate valorile ce caracterizează populatia de interes.
Dacă setul de date al esantionului este normal distribuit (sau

aproape normal distribuit), datele vor determina probabilităţi foarte
particulare, care pot fi exploatate în combinaţie cu media aritmetică şi
deviaţia standard pentru a face predictii despre probabilitatea de aparitia
a unei valori particulare.
Statistica inferentiala permite enuntarea unor:

afirmaţii cantitative probabilistice
afirmaţii cantitative predictive
Distributia normala - Gaussiana
O distributie de date este normala daca:
- este o distributie continua si unimodala
- este simetrica fata de media aritmetica
- graficul distributiei are forma de clopot, atingand inaltimea maxima
pentru media aritmetica
- se apropie de axa orizontala, dar nu o atinge niciodata
Caracteristica cea mai folositoare:
aria de sub grafic – se converteste in probabilitate
probabilitatea de 100% sau probabilitate= 1
Distributia normala - Gaussiana
Afirmatii logice:
- probabilitatea ca toate măsurătorile din setul de date să se afle
între cele două extreme este 100%
-probabilitatea ca orice dată din setul de date considerat să fie mai
mică decât valoarea medie, este 50%
- probabilitatea ca orice dată din setul de date considerat să fie mai
mare decât valoarea medie, este 50%
- cele mai multe valori din setul de date se află în apropierea mediei
- este mai probabil ca o valoare individuală să fie mai aproape de
valoarea medie decât de valorile extreme
- in apropierea extremităţilor se afla mai putine valori decat in
apropierea mediei
KDE – Kernel density function – date continue
Functia de densitarea de probabilitate/ Probability density function
(PDF) – cum este distribuită probabilitatea de valori.
Valorile mai mari pentru PDF indică probabilități mai mari
KDE-urile sunt similare cu histogramele, dar în loc să creeze binuri pentru

date, ele desenează o curbă netezită, care este o estimare a funcției de
densitate de probabilitate a distribuției (PDF)
Probabilitate cumulativa
Probabilitatea cumulativă/Cumulative Distribution function (CDF):
probabilitatea ca o variabilă aleatoare dintr-un set de date să aibă
valoarea într-un anumit domeniu.
CDF este integrala (aria de sub curba) unui PDF

Probabilitate cumulativa
Probabilitatea cumulativă este probabilitatea ca o variabilă aleatoare să

fie mai mică sau egală cu o valoare dată P(X≤x)
Probabilitatea ca o valoare aleatoare sa se afle sub media aritmetica este

50 % P(X ≤ 50)
Distributii comune
Distributiile discrete sunt Probability Mass Function(PMF)in loc de PDF
Scalarea datelor - normalizarea
Pentru a compara variabilele din diferite distribuții trebuie să scalam

datele – normalizam in [0,1]
Z-score - standardizam datele. Obtinem o distributie normala standard

cu media aritmetică = 0 si deviaţia standard = 1
zi reprezinta numărul deviaţiilor standard la care se află valoarea x i

fată de media aritmetică: deasupra (> 0), sub (< 0).
Concluzii
Statistica descriptivă este foarte utila atunci când vrem să cunoaștem

datele, dar fiți precauți, nu vă bazați exclusiv pe ea.
Statisticile vă pot duce în eroare;
Asigurați-vă că vizualizați datele înainte de a trage concluzii sau de a

continua cu analiza.
Bibliografie
https://seaborn.pydata.org/
Seaborn – categorii de funcții după tipul de date:

https://seaborn.pydata.org/api.html
Curs 6
Seaborn
Seaborn
Vizualizări din date în format lung.
Vizualizări de subseturi de date pentru a codifica informații suplimentare

setări de culori pentru diferite categorii.
Personalizați ploturi pentru a le îmbunătăți interpretabilitatea: crearea de

adnotări, adăugarea liniilor de referință, etichetarea corectă a datelor,
controlul paletei de culori, adaptarea axelor.
Creierul uman excelează în găsirea de patternuri - modele vizuale de

reprezentare;
Importul librăriilor
Pregatim mediul de lucru si fișierele cu care vom lucra:
In[]: %pylab
In[]: import seaborn as sns
In[]: import pandas as pd
In[]:fb=pd.read_csv( 'fb_stock2018.csv',
index_col='date',
parse_dates=True)
In[]: qu = pd.read_csv('cutremur.csv')
Fișier de date
Conținutul fișierului fb_stock2018.csv :
Fișier de date
Conținutul fișierului cutremur.csv :
In[]: qu.columns
Index(['mag', 'magType', 'time', 'place', 'tsunami', 'parsed_place'],
dtype='object')
magnitudinea (mag), scara măsurată (magType), data și locația și

parsed_place - indică statul sau țara în care a avut loc un cutremur
Seaborn - stripplot()
A avut loc un tsunami devastator în Indonezia pe 28 septembrie 2018.
Analizăm datele:
In[]: c=qu.assign(time=lambda x: pd.to_datetime(x.time,
unit='ms')) .set_index('time').loc['2018-09-28'].query('parsed_place ==
"Indonesia" ')
Vrem să vizualizăm ce tipuri de magnitudine au fost utilizate în

Indonezia, intervalul de magnitudini înregistrate și câte dintre cutremure
au fost însoțite de un tsunami.
In[]: c=qu.assign(time=lambda x: pd.to_datetime(x.time,

unit='ms')) .set_index('time').loc['2018-09-28'].query('parsed_place ==
"Indonesia" and tsunami ')
Trebuie să facem graficul unei relații între variabile: o variabilă de tip

categorie ( magType ) iar cealaltă variabilă este numerică (mag)
Scatter plots din Pandas sau Matplotlib e limitat la ambele variabile

numerice.
Specificam că vrem magType pe axa x ( x ) și mag pe axa y ( y )
Colorăm punctele dacă cutremurul a fost însoțit de un tsunami (hue)
Extragem subsetul de cutremure care sunt în Indonezia si-l pasăm în
parametrul de date:
In[]: sns.stripplot(x='magType', y='mag', hue='tsunami',

data=qu.query('parsed_place == "Indonesia"'))
Seaborn - swamplot()
Swarmplot (sau bee swarm plot) – vizibilitatea distribuției datelor,
definesc marimea punctelor
In[]: sns.swarmplot( x='magType', y='mag', hue='tsunami',
data=qu.query('parsed_place == "Indonesia"'), size=3.5 )
Seaborn - boxenplot()
Boxenplot pentru seturi mari de date, arată mai multe informații despre
forma distribuției, în special în cozi.
In[]: sns.boxenplot(x='magType', y='mag', data=qu[['magType', 'mag']] )
Seaborn - violinplot()
Violin plot combină o estimare a densității nucleului KDE (estimarea a
distribuția de bază) și un box plot
In[]: fig, axes = subplots(figsize=(10, 5))
In[]: sns.violinplot(x='magType', y='mag', data=qu[['magType', 'mag']],
ax=axes, scale='width')
Faceting
Creăm subploturi în subseturi de date prin fațetare.
1. Trebuie să creăm un FacetGrid - specifică modul de aranjare a

diagramelor (care coloană categorială merge de-a lungul rândurilor și
care de-a lungul coloanelor).
2. Apelăm metoda map() ptr FacetGrid și transmitem funcția de plotare
pe care dorim să o folosim (împreună cu orice argument suplimentar).
Arătăm ce bacsis primesc chenerii unui restaurant pe diverse criterii:
In[]: tips = sns.load_dataset('tips')

In[]: tips.head()
In[]: tips['tip_pct'] = 100 * tips['tip'] / tips['total_bill']
In[]:grid=sns.FacetGrid(tips, row="sex", col="time", margin_titles=True)
In[]: grid.map(plt.hist, "tip_pct", bins=np.linspace(0, 40, 15))
Faceting
Seaborn - jointplot()
jointplot()-comparăm doar două variabile, asemănător cu un scatter plot

dar avem împreună și distribuția fiecărei variabile (ca histograme sau
KDE).
Ptr datele fb (stock-ul Facebook 2018), vizualizăm modul în care

volumul tranzacționat se corelează cu diferența zilnică dintre prețul mare
și cel mic.
In[]: sns.jointplot( x='log_volume',

y='max_abs_change',
data=fb.assign(log_volume=np.log(fb.volume),
max_abs_change=fb.high - fb.low))
kind=”hex” - schimbam forma punctelor

kind=”kde” - a contour plot a densității estimate și cu KDE pe laturi
kind= “reg” - linia de regresie în centru și cu KDEs pe laturi
kind= “resid” - rezidurile din regresie
In[]: sns.jointplot( x='log_volume',

y='max_abs_change',
kind=’kde’,
data=fb.assign(log_volume=np.log(fb.volume),
max_abs_change=fb.high - fb.low))
Seaborn - heatmap()
Heatmap() - corelații între prețurile stockurilor OHLC, log volumului

tranzacționat, max_abs_change=diferența zilniă între del mai mare si cel
mai mic preț
In[]:sns.heatmap(fb.sort_index().assign( log_volume=np.log(fb.volume),
max_abs_change=fb.high – fb.low).corr(), annot=True, center=0,
vmin=-1, vmax=1 )
center=0 (nicio correlație) pentru a marca centrul paletei dec culori

vmin si vmax – setăm scala de culori cu limitele coeficienților de
correlație
annot=True- pentru a scrie coeficienții de corelație în fiecare pătrat
Avantajul de a avea datele numerice și datele vizuale toate într-un singur

grafic cu un singur apel de funcție.
Heatmap
Seaborn - pairplot()
Corelațiile între coloanele din datele din fisierul fb ca scatter plots
In[]: sns.pairplot(fb)
Vizualizăm cum s-a schimbat distribuția datelor în fiecare trimestru
In[]: sns.pairplot(fb.assign(quarter=lambda x:
x.index.quarter),diag_kind='kde', hue='quarter')
hue – ptr a colora distribuțiile
Putem vedea cum distribuțiile coloanelor OHLC au deviația standard mai

scăzută (și varianța mai mică) în primul trimestru și modul în care prețul
stocului a scazut mult în trimestrul al patrulea (distribuția se deplasează
spre stânga)
Bibliografie
https://seaborn.pydata.org/
Seaborn – categorii de funcții după tipul de date:

https://seaborn.pydata.org/api.html
Laborator Statistică
Obiective:
1. Analiza datelor
Verde – Exemple Roșu- Exerciții

A. Exerciții (IPython):
1. Generați urmatoarele date:
from statistics import *

import math
import random
In[]: random.seed(0)
In[]: salariu = [round(random.random()*1000000, -3) for _ in range(100)]
1 Comparați rezultatul calculand media datelor salariu în două moduri: folosind functia
mean() si cu formula.
2. Comparați rezultatul calculand median-ul datelor salariu în două moduri: folosind

functia median() si apeland urmatoarea functie, calcul_median(x):
import math
def calcul_median(x):
x.sort()
mijloc = (len(x) + 1) / 2 - 1 # scad 1, indexare de la 0
if len(x) % 2:
# x are numar impar de valori
return x[int(mijloc)]
else:
return (x[math.floor(mijloc)] + x[math.ceil(mijloc)]) / 2
3. Comparați rezultatul calculand mod-ul datelor salariu în două variante: folosind

functia mode() si apeland urmatoarele instructiuni:
from collections import Counter
Counter(salariu).most_common(1)[0][0]
4. Comparați rezultatul calculand varianta datelor salariu în două moduri: folosind
functia variance() si apeland urmatoarea formula, respectand corectia Bessel:
In[]: sum([(x - sum(salariu) / len(salariu))**2 for x in salariu]) / (len(salariu) – 1)
5. Comparați rezultatul calculand deviatia standard datelor salariu în două moduri:

folosind functia stdev() si apeland urmatoarea formula, respectand corectia Bessel:
In[]: math.sqrt(sum([(x - sum(salariu) / len(salariu))**2 for x in salariu]) / (len(salariu) -

1))
6. Folosind funcțile max() si min() calculati range-ul
Out[]: 995000.0
7. Folosind formula calculați coeficientul de variatie.
Out[]: 0.45386998894439035
8. Calculați coeficientul de dispersie cuartil (CDC).

Pentru a calcula 1 si al 3-lea cuartil, trebuie să modificati functia calcul_median(x) în
fuctia cuartil(x, pct) .
Verificați că se calculeaza corect 1 curtil:
In[]: sum([x < cuartil(salariu, 0.25) for x in salariu]) / len(salariu) == 0.25
Verificați că se calculeaza corect al 3-lea curtil.

q3=cuartil (salariu, 0.75)
Calculați CDC = (q3 - q1) / (q3 + q1)
Out[]: 0.3417928776094965
9. Scalați datele salariu, folosind range-ul calculati lista elementelor x_scalat .

A fișati primele 5 valori:
In[]: x_scalat[: 5 ]
Out[]:
[0.0,
0.01306532663316583,
0.07939698492462312,
0.0814070351758794,
0.08944723618090453]
10. Standardizăm datele – calculati z_score.

Afisati primele 5 valori:
In[]: z_score[: 5]
Out[]:
[-2.199512275430514,
-2.150608309943509,
-1.9023266390094862,
-1.8948029520114855,
-1.8647082040194827]
11. Cititi helpul functiei covariance - np. cov()
Covarianța cuantifica relația dintre variabile: cum se modifică o variabilă în raport cu

alta (se mai numeste și joint variance):
cov (X, Y) = E[(X − E[X])(Y − E[Y])]
E[X] - expecting value (valoarea așteptată) a lui X și se calculează prin însumarea

tuturor valorilor posibile ale lui X înmulțită cu probabilitatea lor - este media pe termen
lung a lui X.
Mărimea covarianței nu este ușor de interpretat, dar semnul ei ne spune dacă variabilele
sunt corelate pozitiv sau negativ.
import numpy as np
In[]: np.cov(x_scalat, z_score)
Out[]:
array([[0.07137603, 0.26716293],
[0.26716293, 1. ]])
Același rezultat 0.26 il obtineți și cu următoarea metodă:
In[]: total = [ (x - mean(x_scalat)) * (y - mean(z_score))

for x, y in zip(x_scalat, z_score) ]
cov = mean(total)
Out[]: 0.26449129918250414
12: Citiți despre Coeficientul de Corelație Pearson (P).
Corelare - cuantificăm cât de puternică este relația dintre variabile.

Corelația ne spune cum variabilele se schimbă împreună în ambele direcție (aceeași sau
opusă) și amploarea (puterea relației).
Aceasta normalizare a covarianței are ca rezultat un numar între -1 și 1, descriind atât

direcția corelației (semnul), cât și magnitudinea ei.
Se spune că corelațiile lui 1 sunt corelații perfect pozitive (liniare), în timp ce cele ale
lui -1 sunt corelații negative perfecte. Valorile apropiate de 0 nu sunt corelate.
Calculati P:
In[]: P= cov / (stdev(x_scalat) * stdev(z_score))
Out[]: 0.9900000000000001
Bibliografie
https://www.statology.org/
Laborator Scikit Learn- Regresie
A1. Exemplu – Regresie Liniară (IPython):

#importul librariilor: atentie cum le folositi
In[]: import numpy as np sau %pylab

In[]:import matplotlib.pyplot as plt
# generăm setul de date de antrenare

In[]: rng = np.random.RandomState(1)
In[]: x = 10 * rng.rand(50)
In[]: y = 2 * x - 5 + rng.randn(50)
In[]: plt.scatter(x, y)
In[]: from sklearn.linear_model import LinearRegression
In[]: model = LinearRegression(fit_intercept=True)

In[]: model.fit(x[:, np.newaxis], y)
In[]: xfit = np.linspace(0, 10, 1000)
In[]: yfit = model.predict(xfit[:, np.newaxis])
In[]: plt.plot(xfit, yfit);
#Optineti aceste? rezultate(random)
In[]: print("Model slope:", model.coef_[0])

In[]: print("Model intercept:", model.intercept_)
Model slope: 2.02720881036
Model intercept: -4.99857708555
A2. Exemplu – Regresie Polinomială (IPython):

Vrem sa modelam polinomul de gradul doi:
y = 0.5x2 + 1.0x +2.0 + zgomot Gaussian
# generăm setul de date de antrenare
In[]: m = 100
In[]: X = 6 * np.random.rand(m, 1) - 3
In[]: y = 0.5 * X**2 + X + 2 + np.random.randn(m, 1)
In[]: plt.scatter(X, y)
In[]: from sklearn.preprocessing import PolynomialFeatures
In[]: pfeatures = PolynomialFeatures(degree=2, include_bias=False)
In[]: X_poly = pfeatures.fit_transform(X)
# valorile sunt in functie de random, exemplu:
In[]:X[0]
array([-0.75275929])
# X_poly contine features/variabilele originale X si patratul lor.
In[]:X_poly[0]
array([-0.75275929, 0.56664654])
In[]: lin_reg = LinearRegression()
In[]: lin_reg.fit(X_poly, y)
In[]: yfit = lin_reg.predict(X_poly)
In[]: plt.scatter(X, y)
In[]: plt.plot(X, yfit)
# Optineti aceste ? rezultate(random):
In[]: lin_reg.coef_
array([[0.93366893, 0.56456263]])
In[]: lin_reg.intercept_
array([1.78134581])
Modelul polinomial estimat y= 0.56x2 + 0.93x + 1.78 cand datele
originale au fost y = 0.5x2 + 1.0x +2.0 + zgomot Gaussian
A1 + A2. Exercițiu (IPython):

a)Aveti urmatorul set de date:
In[]:x = np.array([1, 2, 3, 4, 5])

In[]: y = np.array([4, 2, 1, 3, 7])
b) Generați modelul yfit de Regresie Liniară si desenati-l.
c) Este clar că avem nevoie de un model mai sofisticat decât

modelul liniar pentru a descrie relația între x și y.
Generați modelul de Regresie Polinomială de grad 3
Folosind functia fit_transform () transformati datele, adăugând
coloane suplimentare de caracteristici pentru a genera mai multă
flexibilitate modelului.
Afisati matricea caracteristicilor ce reprezintă pe prima coloana x, a
doua coloana x2 și a treia coloana x3
Generați modelul yfit de Regresie Liniară si desenati-l.
B Managementul datelor lipsa - Imputarea

In[]: X = np.array([[ nan, 0, 3 ],
[ 3, 7, 9 ],
[ 3, 5, 2 ],
[ 4, nan, 6],
[ 8, 8, 1]])
In[]: y = np.array([14, 16, -1, 8, -5])
Imputarea - inlocuim valorile nan cu alte valori folosind mean,
median sau alte valori din clasa Imputer din Scikit-Learn.
In[]: from sklearn.impute import SimpleImputer
In[]: imp = SimpleImputer(strategy='mean')

In[]: X3 = imp.fit_transform(X)
In[]: X3
Acum putem sa folosim datele intr-un estimator de Regresie Liniara
In[]: model = LinearRegression().fit(X3, y)
In[]:model.predict(X3)
C. Pipelines - make_pipeline
Vrem sa eficientizam acest tip de procesare a etapelor. De exemplu:

1. Imputați valorile lipsă
2. Transformați matricea caracteristicilor adaugand valori pătratice
3. Potriviți o regresie liniară
Scikit-Learn oferă un obiect make_pipeline care poate fi folosit:
In[]: from sklearn.pipeline import make_pipeline
In[]: ml = make_pipeline(Imputer(strategy='mean'),
PolynomialFeatures(degree=2),
LinearRegression())
Această se va putea folosi ca oricare obiect standard Scikit-Learn
In[]: ml.fit(X, y)
In[]: print(y)
In[]: print(ml.predict(X))
[14 16 -1 8 -5]
[ 14. 16. -1. 8. -5.]
Folosim modelul liniar generat de make_pipeline pentru a potrivi
relații mult mai complicate între x și y.
C. Exercițiu (IPython):
Vrem sa modelam date neliniare - o funcție sinusoidala (cu ceva
zgomot) cu un model polinomial de grad 7
a)Aveti urmatorul set de date:
In[]: rng = np.random.RandomState(1)
In[]: : x = 10 * rng.rand(50)
In[]: y = np.sin(x) + 0.1 * rng.randn(50)
b) Folosinf make_pipeline generati modelul unui polinom de grad 7.
c) Folosind functiile fit() și predict() potriviti modelul generat de
make_pipeline.
D Exemplu complet - Iris
Pasii ce trebuie urmati in orice proiect ML (folosind Scikit) :
#Am scris codul in general, folosindu-ma de librariile necesare
1.Pregatim/ verificam datele
2.Impartim datele in seturi : train/(validation)/test
3.Cream o instanta a unui model
4.Aplicam functia fit() pe model
5.Facem predictii, aplicam functia predict()
6.Evaluam modelul
# importam date din baza de date Scikit Learn

In[]: from sklearn.datasets import load_iris
In[]: iris = load_iris()
# care sunt features/ variabilele in setul de date?
In[]: iris.feature_names
# vrem sa prezicem latimea petalelor(y) stiind lungimea petalelor(X)

In[]: X = iris.data[:,2] # petal length
In[]: y = iris.data[:,3] # petal width
In[]: X = X[:,np.newaxis] # setam matricea X
In[]: y = y[:,np.newaxis] # setam vectorul y
# vizualizam datele
In[]: fig = plt.figure(figsize=(8,5))
In[]: plt.plot(X, y,'o',color='c')
In[]: plt.show()
# impartim datele in seturi
In[]: from sklearn.model_selection import train_test_split
In[]: from sklearn import metrics
In[]: np.random.seed(5)
In[]: Xtrain, Xtest, ytrain, ytest = train_test_split(X,y, test_size=.3)
# cream o instanta a clasei modelului

lm = LinearRegression()
# fit model
lm.fit(Xtrain, ytrain)
# facem predictii pe setul de date de testare

ypred = lm.predict(Xtest)
# afisam parametrii optimizati

print(lm.coef_, lm.intercept_)
Out[]: [[0.41637834]] [-0.36947008]
# afisam scorul: ptr regresie liniara default este R2

print(lm.score(Xtrain, ytrain))
print(lm.score(Xtest, ytest))
Out[]: 0.9316265852015047
0.9159475920368934
# vizualizam setul de test si regresia liniara
fig = plt.figure(figsize=(8,5))
plt.plot(Xtest, ytest, 'o', color='c', label='Actual')
plt.plot(Xtest, ypred, color='r', label='Prezis')
plt.legend()
plt.show()
E Exemplu complet - curva de validare – Regresie polinomiala

# Generam date
import numpy as np
import matplotlib.pyplot as plt
def make_data(N, err=1.0, rseed=1):
# date random
rng = np.random.RandomState(rseed)
X = rng.rand(N, 1) ** 2
y = 10 - 1. / (X.ravel() + 0.1)
if err > 0:
y += err * rng.randn(N)
return X, y
X, y = make_data(40)
from sklearn.preprocessing import PolynomialFeatures

from sklearn.linear_model import LinearRegression
from sklearn.pipeline import make_pipeline
from sklearn.model_selection import validation_curve
def PolynomialRegression(degree=2, **kwargs):
return make_pipeline(PolynomialFeatures(degree),
LinearRegression(**kwargs))
degree = np.arange(0, 20)
train_scor, val_scor = validation_curve(PolynomialRegression(), X,
y, 'polynomialfeatures__degree', degree, cv=7)
plt.plot(degree, np.median(train_scor, 1), color='blue', label='scor
antrenare')
plt.plot(degree, np.median(val_scor, 1), color='red', label='scor
validare')
plt.legend(loc='best')
plt.ylim(0, 1)
plt.xlabel('grad polinom')
plt.ylabel('scor');
plt.show()
#Polinomul de grad 3 va modela cel mai bine acest set de date X, y:
In[]: scatter(X.ravel(), y)
In[]: X_test = np.linspace(-0.1, 1.1, 500)[:, None]
In[]: y_test = PolynomialRegression(3).fit(X, y).predict(X_test)
In[]: plot(X_test.ravel(), y_test)
Bibliografie
https://scikit-learn.org/stable/
https://scikit-learn.org/stable/modules/linear_model.html
https://www.statsmodels.org/stable/index.html
https://scikit-learn.org/stable/modules/
learning_curve.html#validation-curve
https://en.wikipedia.org/wiki/Coefficient_of_determination
https://scikit-learn.org/stable/modules/sgd.html#regression
Implementare Normal Equation: θ =(XTX)−1XTy

pentru y = 4 + 3x 1 + zgomot Gaussian
import numpy as np
In[]:X = 2 * np.random.rand(100, 1)
In[]: y = 4 + 3 * X + np.random.randn(100, 1)
In[]: X_b = np.c_[np.ones((100, 1)), X] # adaug x0 = 1
In[]: theta_best = np.linalg.inv(X_b.T.dot(X_b)).dot(X_b.T).dot(y)
In[]: theta_best
Out[]: array([[4.21509616],
[2.77011339]])
Implementare Batch Gradient Descent:
θnext step = θ - α
In[]: alfa = 0.1 # learning rate
In[]: n_iterations = 1000
In[]: m = 100
In[]: theta = np.random.randn(2,1)
# initializare random
In[]: for iteration in range(n_iterations):
gradients = 2/m * X_b.T.dot(X_b.dot(theta) - y)
theta = theta - alfa * gradients
In[]: theta
Out[]: array([[4.21509616],
[2.77011339]])
Laborator Scikit-Learn
K-menas
PCA
A1. Exemplu – K-means (IPython):

Algoritmul k-means caută un număr predeterminat de clustere în
într-un set de date multidimensional neetichetat.
#importul librariilor: atentie cum le folositi

In[]: import numpy as np sau %pylab
In[]:import matplotlib.pyplot as plt
# generăm un set de date 2D care conține patru blob-uri distincte.

In[]:from sklearn.datasets import make_blobs
In[]: X, y_true = make_blobs(n_samples=300, centers=4,
cluster_std=0.60, random_state=0)
In[]: plt.scatter(X[:, 0], X[:, 1], s=50)
In[]: from sklearn.cluster import KMeans

In[]: model = Kmeans(n_clusters=4, random_state=42)
In[]: model.fit(X)
In[]: y_kmeans = model.predict(X)
# puteam sa fac si cu functia fit_predict in loc de fit si predict:
# y_kmeans=model.fit_predict(X)
# Fiecare instanta a fost asignata unuia din cele 4 clustere

In[]: y_kmeans
In[]: y_kmeans.shape
# Cei 4 centroizi au fost estimati:
In[]: model.cluster_centers_
Out[]:
array([[-1.37324398, 7.75368871],
[ 1.98258281, 0.86771314],
[ 0.94973532, 4.41906906],
[-1.58438467, 2.83081263]])
# Vizualizăm rezultatele colorand datele din cele 4 clustere și

desenăm și centrele clusterelor așa cum au fost determinate de
estimatorul k-means
In[]: plt.scatter(X[:, 0], X[:, 1], c=y_kmeans, s=50, cmap='viridis')

In[]: centers = model.cluster_centers_
In[]: plt.scatter(centers[:, 0], centers[:, 1], c='black', s=200,
alpha=0.5)
#KMeans păstrează etichetele instanțelor pe care a fost antrenat-
eticheta unei instanțe este indexul clusterului căruia i se atribuie
instanța
In[]: model.labels_
In[]: from sklearn.metrics import silhouette_score
In[]: silhouette_score(X, model.labels_)
Out[]: 0.6819938690643478
# Functia de Cost -Inerția este suma distanțelor pătrate dintre fiecare

instanță de antrenare și cel mai apropiat centroid
In[]: model.inertia_
Out[]: ce valoare obtineti ?
# Functia transform() masoara distance de la fiecare instantă la toti
centroizii
In[]: X_dist = model.transform(X)
In[]: np.sum(X_dist[np.arange(len(X_dist)), model.labels_]**2)
Out[]: ce valoare obtineti ?
# Functia score() are valoarea negativa a inertiei.

In[]: model.score(X)
Atenție!
Algoritmul k-means așteaptă să îi spuneți câte clustere doriți, nu
poate afla numărul de clustere din setul de date. Puteti selecta
numărul de clustere în prealabil:
In[]: labels = KMeans(6, random_state=0).fit_predict(X)

In[]: plt.scatter(X[:, 0], X[:, 1], c=labels, s=50, cmap='viridis')
A2. Exemplu – Clustering pentru Color Segmentation (Spyder):

Atribuim pixeli aceluiași segment dacă au o culoare similară.
O imagine este reprezentată ca o matrice 3D. Prima dimensiune este

înălţimea, a doua este lățimea, iar al treilea este numărul de canale
de culori, în acest caz 3: roșu, verde și albastru (RGB).
Pentru fiecare pixel există un vector 3D care con ține intensită țile de
roșu, verde și albastru, fiecare între 0 și 1 (sau între 0 și 255, dacă
utilizați imageio.imread() ).
Unele imagini pot avea mai puține canale, imagini în tonuri de gri
(un canal), altele pot avea mai multe canale, cum ar fi imagini cu un
canal alfa suplimentar pentru transparență, sau imagini din satelit,
care conțin canale pentru multe frecvențe luminoase (infrared).
Incarcam o imagine:
from sklearn.datasets import load_sample_image
image = load_sample_image("flower.jpg")
data = image / 255.0 # folosim 0...1 scale
In[]: imagine.shape
Out[]:?
Re aranjam matricea imaginii pentru a obține listă de culori RGB:
X = data.reshape(-1, 3)
In[]: X.shape
Out[]: (273280, 3)
Grupăm aceste culori folosind K-Means:
from sklearn.cluster import Kmeans

kmeans = KMeans(n_clusters=8).fit(X)
segmented_img = kmeans.cluster_centers_[kmeans.labels_]
segmented_img = segmented_img.reshape(image.shape)
Cream lista imaginilor segmentate în funcție de nr de culori

segmented_imgs = []
n_colors = (10, 8, 6, 4, 2)
for n_clusters in n_colors:
kmeans = Kmeans(n_clusters=n_clusters,random_state=42).fit(X)
segmented_img = kmeans.cluster_centers_[kmeans.labels_]
segmented_imgs.append(segmented_img.reshape(image.shape))
Afisam rezultatele segmentarii:

plt.figure(figsize=(10,5))
plt.subplots_adjust(wspace=0.05, hspace=0.1)
plt.subplot(231)
plt.imshow(image)
plt.title("Original image")
plt.axis('off')
for idx, n_clusters in enumerate(n_colors):
plt.subplot(232 + idx)
plt.imshow(segmented_imgs[idx])
plt.title("{} colors".format(n_clusters))
plt.axis('off')
plt.show()
Se identifica un cluster de culoare pentru toate nuanțele de verde.
Următorul, pentru fiecare culoare (de exemplu, verde închis), caută
culoarea medie a pixelilor clusterelor de culori. Toate nuan țele de
verde pot fi înlocuite cu aceeași culoare verde deschis (presupunând
că culoarea medie a clusterului verde este verde deschis).
Dacă folosiți mai puțin de opt clustere, observați că culoarea mai
roșie din mijlocul florii nu reușește să obțină un cluster propriu: se
îmbină cu culorile din mediu inconjurator. Acest lucru se datorează
faptului că K-Means preferă clustere de dimensiuni similare.
A3. Exemplu – K-means Clusterizarea cifrelor (Spyder):

Identificam cifre similare fără a utiliza informa țiile originale ale
etichetelor cifrelor
Incărcam cifrele și apoi vom găsi clusterele Kmeans.
Cifrele – un set de date care conține 1.797 imagini, reprezentând

cifrele de la 0 la 9. Imaginile sunt în tonuri de gri 8 × 8, deci 64 de
caracteristici, unde fiecare dintre cele 64 de caracteristici este
luminozitatea unui pixel:
from sklearn.datasets import load_digits
digits = load_digits()
print(digits.data.shape)
from sklearn.cluster import KMeans
kmeans = KMeans(n_clusters=10, random_state=0)
clusters = kmeans.fit_predict(digits.data)
kmeans.cluster_centers_.shape
Obtinem 10 clustere fiecare de dimensiunea 64. Observați ca
clusterul se centrează singur și pot fi interpretate ca cifra „tipică”.
în cadrul clusterului.
Să vedem cum arată aceste centre de cluster:
fig, ax = plt.subplots(2, 5, figsize=(8, 3))
centers = kmeans.cluster_centers_.reshape(10, 8, 8)
for axi, center in zip(ax.flat, centers):
axi.set(xticks=[], yticks=[])
axi.imshow(center, interpolation='nearest', cmap=plt.cm.binary)
Chiar și fără etichete, KMeans este capabil să găsească clustere ale
căror centre sunt identificabile, poate cu excepția lui 1 și 8.
k-means nu știe nimic despre etichetele 0-9 care pot fi permutate.
Potrivim fiecare etichetă de cluster învățată cu cea adevărata:
from scipy.stats import mode
import numpy as np
labels = np.zeros_like(clusters)
for i in range(10):
mask = (clusters == i)
labels[mask] = mode(digits.target[mask])[0]
Verificam cât de precisă a fost clusterizarea în găsirea unor cifre
similare din date:
from sklearn.metrics import accuracy_score
print(accuracy_score(digits.target, labels))
K-means a descoperit clusterizarea corectă pentru 80% din
cifrele de intrare!
Verificăm si matricea de confuzie:
from sklearn.metrics import confusion_matrix
import seaborn as sns
mat = confusion_matrix(digits.target, labels)
sns.heatmap(mat.T, square=True, annot=True, fmt='d', cbar=False,
xticklabels=digits.target_names,
yticklabels=digits.target_names)
plt.xlabel('true label')
plt.ylabel('predicted label')
Așa cum ne-am așteptat de la centroizii clusterelor pe care le-am

vizualizat punctul principal al confuziei este ptr 8 și 1.
Dar în ciuda acestui lucru, putem folosi k-means, putem construi un
clasificator de cifre fără referire la nicio etichetă cunoscută!
B1 Exemplu- Principal Component Analysis (PCA) (Spyder)

PCA cuantifică relația dintre features prin găsirea unor axe
principale in date și utilizarea acestor axe pentru a descrie setul de
date.
Generam datele, 200 de puncte:
import numpy as np
rng = np.random.RandomState(1)
X = np.dot(rng.rand(2, 2), rng.randn(2, 200)).T
plt.scatter(X[:, 0], X[:, 1])
plt.axis('equal')
from sklearn.decomposition import PCA
pca = PCA(n_components=2)
pca.fit(X)
X_pca = pca.transform(X)
print(pca.components_)
# [[-0.94446029 -0.32862557]
[-0.32862557 0.94446029]]
print(pca.explained_variance_)
# [ 0.75871884 0.01838551]
Pentru a vedea ce înseamnă aceste numere, le vizualizăm ca vectori
suprapusi pe datele de intrare. Folosind „componentele” pentru a
defini direcția vectorului și „explainded_variance” pentru a defini
lungimea vectorului
def draw_vector(v0, v1, ax=None):

ax = ax
arrowprops=dict(arrowstyle='->',linewidth=2,shrinkA=0,
shrinkB=0)
ax.annotate('', v1, v0, arrowprops=arrowprops,)
fig, ax = plt.subplots(1, 2, figsize=(16, 6))
# plot data
ax[0].scatter(X[:, 0], X[:, 1], c= 'k', alpha=0.2)
for length, vector in zip(pca.explained_variance_,pca.components_):
v = vector * 3 * np.sqrt(length)
draw_vector(pca.mean_, pca.mean_ + v, ax=ax[0])
ax[0].axis('equal');
ax[0].set(xlabel='x', ylabel='y', title='input')
# plot componentele principale

ax[1].scatter(X_pca[:, 0], X_pca[:, 1], c= 'r', alpha=0.2)
draw_vector([0, 0], [0, 3], ax=ax[1])
draw_vector([0, 0], [3, 0], ax=ax[1])
ax[1].axis('equal')
ax[1].set(xlabel='component 1', ylabel='component 2',
title='principal components',
xlim=(-5, 5), ylim=(-3, 3.1))
B2 PCA – reducerea dimensionalitatii (Spyder)
import numpy as np
Generam datele, 200 de puncte:
rng = np.random.RandomState(1)
X = np.dot(rng.rand(2, 2), rng.randn(2, 200)).T
plt.scatter(X[:, 0], X[:, 1])
plt.axis('equal')
pca = PCA(n_components=1)
pca.fit(X)
X_pca = pca.transform(X)
print("original shape: ", X.shape)
print("transformed shape:", X_pca.shape)
# datele au fost reduse la 1 dimensiune
Pentru a înțelege efectul acestei reduceri de dimensionalitate, putem
efectua transformarea inversă a acestor date reduse și sa le
reprezentam împreună cu datele originale
X_new = pca.inverse_transform(X_pca)
plt.scatter(X[:, 0], X[:, 1], alpha=0.2)
plt.scatter(X_new[:, 0], X_new[:, 1], alpha=0.8)
plt.axis('equal')
B3 PCA – Eigenfaces (Spyder)

Folosim un set de date cu fete etichetate - câteva mii de fotografii
adunate ale diferitelor persoane publice. Fiecare imagine contine
62×47 aproximativ 3,000 pixeli.
import numpy as np
from sklearn.datasets import fetch_lfw_people
faces = fetch_lfw_people(min_faces_per_person=60)
print(faces.target_names)
['Ariel Sharon' 'Colin Powell' 'Donald Rumsfeld' 'George W Bush'
'Gerhard Schroeder' 'Hugo Chavez' 'Junichiro Koizumi' 'Tony Blair']
print(faces.images.shape)
(1348, 62, 47)
Desenam aceste fete:
fig, ax = plt.subplots(3, 5)
for i, axi in enumerate(ax.flat):
axi.imshow(faces.images[i], cmap='bone')
axi.set(xticks=[], yticks=[],
xlabel=faces.target_names[faces.target[i]])
Deoarece acesta este un set de date mare (de aproape 3.000) folosim
RandomizedPCA - o metodă randomizată pentru a aproxima
primele componente principale mult mai rapid decât estimatorul
standard PCA . Extragem primele 150 de componente:
from sklearn.decomposition import PCA as RandomizedPCA
pca = RandomizedPCA(150)
pca.fit(faces.data)
Vizualizam imaginile asociate cu primele câteva componente

principale (aceste componente sunt cunoscute ca eigenvectors
„vectori proprii”, si aceste tipuri de imagini sunt adesea numite
eigenfaces „fețe proprii”)
fig, axes = plt.subplots(3, 8, figsize=(9, 4),

subplot_kw={'xticks':[], 'yticks':[]},
gridspec_kw=dict(hspace=0.1, wspace=0.1))
for i, ax in enumerate(axes.flat):
ax.imshow(pca.components_[i].reshape(62, 47), cmap='bone')
Rezultatele ne oferă o perspectivă asupra modului în care variază
imaginile: primele câteva fețe proprii (din stânga sus) sunt asociate
cu unghiul de iluminare pe față, iar mai târziu vectorii principali
descriu caracteristici, cum ar fi ochii, nasul și buzele.
Pentru a vedea cât de mult din informațiile datelor sunt păstrate in

proiecții calculam variația cumulată a acestor componente :
plt.plot(np.cumsum(pca.explained_variance_ratio_))
plt.xlabel('number of components')
plt.ylabel('cumulative explained variance')
150 de componente reprezintă puțin peste 90% din variație -

folosind aceste 150 de componente, vom recupera cea mai mare
parte caracteristicile esențiale ale datelor.
Putem compara imaginile de intrare cu imaginile reconstruite din
aceste 150 de componente:
# Calculam componentele și proiectiile fatelor

pca = RandomizedPCA(150).fit(faces.data)
components = pca.transform(faces.data)
projected = pca.inverse_transform(components)
# desenam resultate
fig, ax = plt.subplots(2, 10, figsize=(10, 2.5),
subplot_kw={'xticks':[], 'yticks':[]},
gridspec_kw=dict(hspace=0.1, wspace=0.1))
for i in range(10):
ax[0, i].imshow(faces.data[i].reshape(62, 47), cmap='binary_r')
ax[1, i].imshow(projected[i].reshape(62, 47), cmap='binary_r')
ax[0, 0].set_ylabel('full-dim\ninput')
ax[1, 0].set_ylabel('150-dim\nreconstruction')
Imaginile proiectate conțin suficiente informații să putem

recunoaște indivizii din imagini. Asta insemană că un algoritm de
clasificare trebuie să fie antrenat pe date de 150 de dimensiuni, mai
degrabă decât pe datele cu 3.000 de dimensiuni - o clasificare mult
mai eficientă.
Bibliografie
https://scikit-learn.org/stable/
https://scikit-
learn.org/stable/auto_examples/cluster/plot_kmeans_silhouette_anal
ysis.html
1. Folosind functia load_diabetes() incarcati setul de date din pachetul sklearn.
Afisati informatii despre setul de date si numele cracteristicilor.
Considerati setul de date format numai din cele 6 caracteristici, “s1”-“s6”.
Folosind PCA reduceti setul de date la 2 componente, afisati-le si vizualizati-le grafic. (Hint: scalati
datele inainte sa aplicati PCA).
import numpy as np
from sklearn.linear_model import LinearRegression
from sklearn.datasets import load_diabetes
diabet= load_diabetes(as_frame=True)
X = diabet.data['bmi']
y = diabet.data['bp']
X = X[:,np.newaxis]
y = y[:,np.newaxis]
plt.plot(X, y,'o',color='c')
plt.show()
import numpy as np
import pandas as pd
from sklearn.datasets import load_diabetes
diabet = load_diabetes()
#print(diabet.DESCR)
diabet.data
diabet.feature_names
from sklearn.model_selection import train_test_split

from sklearn import metrics
np.random.seed(5)
Xtrain, Xtest, ytrain, ytest = train_test_split(X,y, test_size=.25)
lm = LinearRegression()
lm.fit(Xtrain, ytrain)
ypred = lm.predict(Xtest)
print(lm.coef_, lm.intercept_)
plt.plot(Xtest, ytest, 'o', color='c', label='Actual')
plt.plot(Xtest, ypred, color='r', label='Prezis')
plt.legend()
plt.show()

from sklearn.preprocessing import StandardScaler
import numpy as np
df2=pd.DataFrame(diabet.data,columns =[diabet.feature_names])
#df2['target']=pd.Series(data=diabet.target,index=df2.index)
df2=df2.drop(df2.columns[:4],axis=1)
x=df2.values
x=StandardScaler().fit_transform(x)
pca = PCA(n_components=2) #imparte in doua componenete
pca = pca.fit_transform(x) #functie transformare
plt.scatter(x[:,0],x[:,1], label = "componenta 1")
plt.scatter(pca[:,0], pca[:,1], label = "componenta 2")
plt.legend()
plt.title('Grafic 2 componente')
plt.show()
2. Exercitiu cu setul de date iris

iris = sns.load_dataset('iris')
iris.describe() #afiseaza informatiile
iris.shape
iris.shape
n=sns.FacetGrid(iris,row='species') #numele tabelei

n.map(plt.hist,'petal_length')
sns.heatmap(iris.corr())
3. Folosind functia load_breast_cancer() incarcati setul de date din pachetul sklearn.

Afisati informatii despre setul de date, dimensiunea setului de date si numele caracteristicilor.
Cu acest set de date creati un DataFrame ale carui coloane sa fie doar caracteristicile “mean” (primele
10). Afisati primele 7 exemple ale setului de date.
Folosind Seaborn vizualizati matricea de corelatie pentru aceste caracteristici.
#varianta 1
import numpy as np
import pandas as pd
from sklearn.datasets import load_breast_cancer
cancer = load_breast_cancer()
print(cancer.DESCR)
cancer.target_names
cancer.data
cancer.feature_names
cancer.target_names
df=pd.DataFrame(cancer.data,columns =[cancer.feature_names])
#df['target']=pd.Series(data=cancer.target,index=df.index)
df=df.drop(df.columns[:20],axis=1) #!are 30 de coloane in total
df
df[-4:]
df.corr

sns.heatmap(df.corr(),annot=True)

help(sns.heatmap)
#varianta 2
import numpy as np
import pandas as pd
cancer.target_names
cancer.data
df['target']=pd.Series(data=cancer.target,index=df.index)
df.head()
sns.heatmap(df.corr())
print(cancer.target_names)
cancer.data
print(cancer.feature_names)
df['target']=pd.Series(data=cancer.target,index=df.index)
a = list (df[cancer.feature_names[0:10]])
df[a].head(7)
c = sns.heatmap(df[a].corr(),annot = True)

Curs 6: No Iuni de Statistică Ț

Î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

Curs 6: No Iuni de Statistică Ț

Încărcat de

Drepturi de autor:

Formate disponibile

Curs 6

Obiectiv principal : studiul datelor obtinute pe baza unei (sau mai

Anumite tendinte de evolutie pot capata caracter de regularitate.

Statistica cuprinde multitudinea de procedee pentru analiza, interpretarea,

Pentru o abordare stiintifica corecta trebuie respectate standardele privind

Variabile (date): multimea de valori pe care o caracteristica le poate lua

Date cantitative (măsurabile )

Diferite surse de colectare a datelor:

API - colectăm date cu cereri HTTP

Baze de date (cu SQL sau alt limbaj)

Site-urile web publice/guvernamentale( Yahoo! Finance etc)

Web scraping - extrag date din website HTML-ul (exemplu de pachete

Vrem să adăugăm/eliminăm din setul de date inițial, să reformata ți, să

Pregătirea datelor este procesul de introducere a acestora într-un format

Erori umane: datele sunt înregistrate/colectate incorect (New York City ,

Populatie statistica: o multime de elemente (indivizi) cu anumite insusiri

Datele sunt denumite eșantioane (samples) care au fost observate dintr-o

Statistică descriptivă - căutăm să descriem eșantionul.

Statistică inferenţială (predictivă) - căutăm să inferăm/deducem ceva

Statistica descriptiva: se ocupa cu culegerea datelor si determinarea unor

Statistica predictivă: se ocupa cu obtinerea de concluzii asupra unei

Eșantionul(sample) trebuie să fie un eșantion aleator (random sample)

A. esantionarea randomizata - elementele sunt selectate aleator din

B. esantionarea sistematica - este selectat fiecare al k-lea element din

C. esantionarea stratificata (bootstapping ) se realizeaza în doua etape:

D. esantionarea cluster se realizeaza în doua etape:

Media - măsura valorii centrale a setului de date în jurul căruia

Media eșx antionului xx (se pronuntă X-bar) si estimatorul mediei

Mode - valoarea ce are cea mai mare frecventa in setul de date.

Distribuții bimodale sau multimodale - distribuții cu două sau mai multe

Cuartilele împart datele în patru (25%, 50%, 75% și 100%). Sunt 3:

Decilele împart o distribuţie în zece părţi egale. Sunt 9:

Percentilele împart o distribuție în 100 părți egale. Sunt 99.

Deviația cuartilă(DQ)/ Interquartile range(IQR)- răspândirea datelor în

Măsoară dispersia datelor aflate in zona de mijloc a distribuţiei:

QCD Se calculează împărțind intervalul semi-quartil (jumătate din IQR) la

QCD Se calculează împărțind intervalul semi-quartil (jumătate din IQR) la

Histograma - distribuția în frecvență a datelor

Cum sunt dispersate datele - cum se încadrează valorile datelor în jurul

Măsura împraștierii (dispersiei) setului de date:

- ofera informații privind extinderea datelor

- este utila în stabilirea reprezentativitatii masurilor de centralitate

-are rol în estimarea parametrilor statistici și în inferența (predicția)

Domeniul de dispersie (DD) / Range

Nu ne dă informația despre împrăștierea în jurul valorii centrale.

Se bazeaza doar pe valorile extreme.

Varianța populatiei σ 2 (sigma-squared) și varianța eșantionului s 2 .

Unitatea de măsură este egală cu pătratul unității de măsură a valorilor

Corectia Bessel – o estimare unbias a variantei populatiei – cand calculăm

Deviația standard - reprezinta "distanta euclidiana" a valorilor fata de

Deviatia standard a populatiei reprezentată cu σ si deviatia standard a

Este rădăcina pătrată a varianței, oferindu-ne o măsură în aceleași unități

Coeficientul de variatie (CV) - o măsură relativă a dispersiei datelor.

CV- este raportul dintre deviația standard și medie

CV <10% populatie omogena

Abaterea de la aspectul simetric al distributiei de frecventa.

Aplatizarea/inaltimea unei distributii in raport cu o distributie normala.

Dacă dorim să ştim cum arată evoluţia în timp a unei anumite

Dacă setul de date al esantionului este normal distribuit (sau

Statistica inferentiala permite enuntarea unor:

Valorile mai mari pentru PDF indică probabilități mai mari

KDE-urile sunt similare cu histogramele, dar în loc să creeze binuri pentru

CDF este integrala (aria de sub curba) unui PDF