Kuigi andmebaasid pakuvad väga tõhusaid viise andmete salvestamiseks ja nende pärimiseks päringukeelte abil, on kõige paindlikum viis andmete töötlemiseks kirjutada oma programm, mis andmeid manipuleerib. Paljudel juhtudel oleks andmebaasi päring tõhusam lahendus. Kuid mõnel juhul, kui on vaja keerukamat andmetöötlust, ei saa seda lihtsalt SQL-i abil teha.
Andmetöötlust saab programmeerida mis tahes programmeerimiskeeles, kuid on teatud keeled, mis on andmetega töötamisel kõrgemal tasemel. Andmeteadlased eelistavad tavaliselt ühte järgmistest keeltest:
Kuigi andmebaasid pakuvad väga tõhusaid võimalusi andmete salvestamiseks ja päringute tegemiseks päringukeeles, on andmetöötluse kõige paindlikum viis oma programmi kirjutamine andmete manipuleerimiseks. Paljudel juhtudel on andmebaasi päring tõhusam meetod. Kuid mõnel juhul, kui on vaja keerulisemat andmetöötlust, ei ole see SQL-iga kerge.
Andmetöötlust saab programmeerida mis tahes programmeerimiskeeles, kuid mõned keeled on kõrgema tasemega andmetöötluse osas. Andmeteadlased eelistavad tavaliselt ühte järgmistest keeltest:
* **[Python](https://www.python.org/)**, üldotstarbeline programmeerimiskeel, mida peetakse sageli üheks parimaks valikuks algajatele selle lihtsuse tõttu. Pythonil on palju lisateeke, mis aitavad lahendada mitmeid praktilisi probleeme, näiteks andmete ekstraheerimine ZIP-arhiivist või pildi teisendamine halltoonidesse. Lisaks andmeteadusele kasutatakse Pythoni sageli ka veebiarenduses.
* **[R](https://www.r-project.org/)** on traditsiooniline tööriistakomplekt, mis on välja töötatud statistiliste andmete töötlemiseks. Sellel on suur teekide repository (CRAN), mis teeb sellest hea valiku andmetöötluseks. Kuid R ei ole üldotstarbeline programmeerimiskeel ja seda kasutatakse harva väljaspool andmeteaduse valdkonda.
* **[Julia](https://julialang.org/)** on veel üks keel, mis on spetsiaalselt välja töötatud andmeteaduse jaoks. Selle eesmärk on pakkuda paremat jõudlust kui Python, muutes selle suurepäraseks tööriistaks teaduslikeks katsetusteks.
* **[Python](https://www.python.org/)**, üldotstarbeline programmeerimiskeel, mida peetakse sageli üheks parimaks võimaluseks algajatele tänu selle lihtsusele. Pythonil on palju lisaraamatukogusid, mis aitavad lahendada mitmeid praktilisi probleeme, näiteks andmete väljavõtmist ZIP-arhiivist või pildi muundamist halltooniks. Lisaks andmeteadusele kasutatakse Pythoni sageli ka veebiarenduses.
* **[R](https://www.r-project.org/)** on traditsiooniline tööriistakomplekt, mis on loodud statistilise andmetöötluse jaoks. Sellel on suur raamatukogude hoidla (CRAN), mis teeb sellest hea valiku andmetöötluseks. Kuid R ei ole üldotstarbeline programmeerimiskeel ja seda kasutatakse harva väljaspool andmeteaduse valdkonda.
* **[Julia](https://julialang.org/)** on veel üks keel, mis on spetsiaalselt arendatud andmeteadusele. Selle eesmärk on pakkuda paremat jõudlust kui Python, muutes selle suurepäraseks tööriistaks teaduslikeks katseteks.
Selles õppetükis keskendume Pythoni kasutamisele lihtsaks andmetöötluseks. Eeldame, et olete keelega põgusalt tuttav. Kui soovite Pythoni kohta põhjalikumat ülevaadet, võite viidata ühele järgmistest ressurssidest:
Selles õppetükis keskendume Pythonile lihtsate andmetöötlusülesannete lahendamiseks. Eeldame keele põhiteadmisi. Kui soovite Pythoniga põhjalikumat tutvust teha, võite vaadata üht järgmistest ressurssidest:
* [Õpi Pythonit lõbusalt Turtle Graphicsi ja fraktalitega](https://github.com/shwars/pycourse) - GitHubi-põhine kiire sissejuhatus Pythoni programmeerimisse
* [Astuge esimesed sammud Pythoniga](https://docs.microsoft.com/en-us/learn/paths/python-first-steps/?WT.mc_id=academic-77958-bethanycheum) Õppeprogramm [Microsoft Learn](http://learn.microsoft.com/?WT.mc_id=academic-77958-bethanycheum) lehel
* [Õpi Python lõbusal viisil koos kilpkonnagraafika ja fraktaalidega](https://github.com/shwars/pycourse) - GitHubil põhinev kiire sissejuhatus Pythoni programmeerimisse
* [Tee oma esimesed sammud Pythoniga](https://docs.microsoft.com/en-us/learn/paths/python-first-steps/?WT.mc_id=academic-77958-bethanycheum) Õppeteek [Microsoft Learn'is](http://learn.microsoft.com/?WT.mc_id=academic-77958-bethanycheum)
Andmed võivad esineda mitmel kujul. Selles õppetükis käsitleme kolme andmevormi - **tabelandmed**, **tekst** ja **pildid**.
Andmed võivad esineda mitmel kujul. Selles õppetükis käsitleme kolme andmetüüpi - **tabelandmed**, **tekst** ja **pildid**.
Keskendume mõnele andmetöötluse näitele, selle asemel et anda täielik ülevaade kõigist seotud teekidest. See võimaldab teil saada peamise idee sellest, mis on võimalik, ja jätta teile arusaama, kust leida lahendusi oma probleemidele, kui neid vajate.
Keskendume mõnedel näidete andmetöötlusest, mitte kõigi seotud raamatukogude täielikule ülevaatele. See võimaldab teil saada põhimõtte selgeks, mis on võimalik, ning annab arusaama, kust leida lahendusi probleemidele, kui teil neid vaja on.
> **Kõige kasulikum nõuanne**. Kui teil on vaja teha teatud toimingut andmetega, mida te ei oska, proovige otsida seda internetist. [Stackoverflow](https://stackoverflow.com/) sisaldab tavaliselt palju kasulikke Pythoni koodinäiteid paljude tüüpiliste ülesannete jaoks.
> **Kõige kasulikum nõuanne**. Kui peate andmetel sooritama mõne toimingu, mida te ei oska, proovige otsida internetist. [Stackoverflow](https://stackoverflow.com/) sisaldab tavaliselt palju kasulikke näidiskoodide lahendusi Pythonis paljude tüüpiliste ülesannete jaoks.
Olete juba kohtunud tabelandmetega, kui rääkisime relatsioonilistest andmebaasidest. Kui teil on palju andmeid ja need on salvestatud paljudesse erinevatesse seotud tabelitesse, on kindlasti mõistlik kasutada SQL-i nende töötlemiseks. Kuid on palju juhtumeid, kus meil on tabel andmetega ja me peame saama nende andmete kohta **arusaama** või **teadmisi**, näiteks jaotuse, väärtuste korrelatsiooni jne. Andmeteaduses on palju juhtumeid, kus peame tegema algandmete transformatsioone, millele järgneb visualiseerimine. Mõlemad sammud saab hõlpsasti teha Pythoniga.
Olete juba kohtunud tabelandmetega, kui rääkisime relatsiooniandmebaasidest. Kui teil on palju andmeid, mis paiknevad paljudes erinevates seotud tabelites, on kindlasti mõistlik kasutada SQL-i nende töötlemiseks. Kuid paljudel juhtudel on meil olemas andmetabel, mille põhjal soovime saada mingit **arusaamist** või **teadmisi**, näiteks jaotust, väärtuste korrelatsiooni jne. Andmeteaduses on palju olukordi, kus on vaja teha originaalandmete transformatsioone, millele järgneb visualiseerimine. Mõlemad sammud saab hõlpsasti teha Pythoniga.
Pythonis on kaks kõige kasulikumat teeki, mis aitavad teil tabelandmetega toime tulla:
* **[Pandas](https://pandas.pydata.org/)** võimaldab manipuleerida nn **DataFrame'idega**, mis on analoogsed relatsiooniliste tabelitega. Teil võivad olla nimetatud veerud ja saate teha erinevaid toiminguid ridade, veergude ja DataFrame'ide üldiselt.
* **[Numpy](https://numpy.org/)** on teek, mis töötab **tensori**, st mitmemõõtmeliste **massiividega**. Massiiv sisaldab sama aluseks oleva tüübi väärtusi ja on lihtsam kui DataFrame, kuid pakub rohkem matemaatilisi operatsioone ja tekitab vähem koormust.
Pythoni kõige kasulikumad teegid tabelandmetega töötamiseks on:
* **[Pandas](https://pandas.pydata.org/)** võimaldab teil manipuleerida nn **DataFrame'idega**, mis on analoogsed relatsioonitabelitele. Saate nimega veerge ning teha erinevaid operatsioone ridade, veergude ja andmeraamidega üldiselt.
* **[Numpy](https://numpy.org/)** on teek, mis on mõeldud **tensooridega** töötamiseks, st mitmemõõtmeliste **massiividega**. Massiiv sisaldab sama andmetüübiga väärtusi ning on lihtsam kui DataFrame, kuid pakub rohkem matemaatilisi operatsioone ning tekitab vähem lisakulu.
Samuti on paar muud teeki, mida peaksite teadma:
* **[Matplotlib](https://matplotlib.org/)** on teek, mida kasutatakse andmete visualiseerimiseks ja graafikute joonistamiseks
* **[SciPy](https://www.scipy.org/)** on teek, mis sisaldab mõningaid täiendavaid teaduslikke funktsioone. Oleme selle teegiga juba kokku puutunud, kui rääkisime tõenäosusest ja statistikast.
On ka paar muud teeki, mida tasub teada:
* **[Matplotlib](https://matplotlib.org/)** on teek andmete visualiseerimiseks ja graafikute joonistamiseks
* **[SciPy](https://www.scipy.org/)** on teek mõnede lisateaduslike funktsioonidega. Oleme sellele juba varem tähelepanu pööranud tõenäosuse ja statistika teemas.
Siin on koodijupp, mida tavaliselt kasutaksite nende teekide importimiseks oma Pythoni programmi alguses:
Järgmine koodilõik on tüüpiline viis nende teekide importimiseks Pythoni programmi alguses:
```python
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy import ... # you need to specify exact sub-packages that you need
from scipy import ... # peate täpsustama täpsed alam-paketid, mida vajate
```
Pandas keskendub mõnele põhimõistele.
Pandas põhineb mõnel põhimõttel.
### Series
### Seeria (Series)
**Series** on väärtuste järjestus, mis sarnaneb loendi või numpy massiiviga. Peamine erinevus seisneb selles, et Series'il on ka **indeks**, ja kui me Series'iga töötame (nt. liidame neid), võetakse indeks arvesse. Indeks võib olla nii lihtne kui täisarvuline rea number (see on indeks, mida kasutatakse vaikimisi Series'i loendist või massiivist loomisel) või see võib olla keeruka struktuuriga, näiteks kuupäeva intervall.
**Series** on väärtuste jada, sarnane listile või numpy massiivile. Peamine erinevus on see, et series'il on ka **indeks**, ning kui me töötleme series (nt liitmisel), võetakse indeks arvesse. Indeks võib olla niisama lihtne kui täisarvuline rea number (see on vaikimisi indeks, mis lisatakse listist või massiivist series'i loomisel), või keerukam struktuur, näiteks kuupaeva intervall.
> **Märkus**: Mõningane sissejuhatav Pandas kood on kaasasolevas märkmikus [`notebook.ipynb`](notebook.ipynb). Siin toome välja ainult mõned näited, kuid kindlasti olete oodatud tutvuma täieliku märkmikuga.
> ** Märkus**: Saate tutvuda mõningate Pandas'i algkoodinäidetega kaasnevas märkmikus [`notebook.ipynb`](notebook.ipynb). Me toome siin vaid mõned näited ning kindlasti on soovitatav vaadata kogu märkmikku.
Vaatame näidet: soovime analüüsida meie jäätisekohviku müüki. Loome müüginumbrite Series'i (müüdud esemete arv iga päev) teatud ajavahemiku kohta:
Vaatame näidet: soovime analüüsida oma jäätisekohviku müüki. Genereerime müüginumbrite seeria (iga päev müüdud kaupade arv) mingiks ajavahemikuks:
Oletame nüüd, et igal nädalal korraldame sõpradele peo ja võtame peole lisaks 10 pakki jäätist. Saame luua teise Series'i, mis on indekseeritud nädala järgi, et seda näidata:
Oletame nüüd, et iga nädal korraldame sõpradele peo ning võtame lisaks veel 10 pakki jäätist kaasa. Selleks loome teise seeria, mille indeksiks on nädal, et seda näidata:
> **Märkus**: Me ei kasuta lihtsat süntaksit `total_items+additional_items`. Kui me seda teeksime, saaksime palju `NaN` (*Not a Number*) väärtusi tulemuseks olevas Series'is. See on tingitud sellest, et `additional_items` Series'is puuduvad väärtused mõne indeksi punkti jaoks ja `NaN` lisamine millelegi annab tulemuseks `NaN`. Seetõttu peame liitmisel määrama `fill_value` parameetri.
> **Tähelepanu**: me ei kasuta lihtsat süntaksit `total_items+additional_items`. Kui oleksime, oleks tulemuseks palju `NaN` (*Not a Number*) väärtusi seerias. Põhjus on selles, et some indeksikohtades `additional_items` seerias väärtusi puudub, ning `NaN` lisamine millelegi annab tulemuseks `NaN`. Seetõttu tuleb liitmisel kasutada `fill_value` parameetrit.
Ajaseeriatega saame ka **ümberproovida** seeriat erinevate ajavahemikega. Näiteks kui soovime arvutada keskmist müügimahtu kuus, saame kasutada järgmist koodi:
Ajaseeria puhul saame ka **ümberproovida** ehk resample'ida seeriat erinevate ajavahemikega. Näiteks soovime arvutada keskmist müügitulemust kuude kaupa. Selleks kasutame järgmist koodi:
Siin `.T` tähendab DataFrame'i transponeerimise operatsiooni, st ridade ja veergude vahetamist, ja `rename` operatsioon võimaldab meil veerge ümber nimetada, et need vastaksid eelmisele näitele.
Siin `.T` tähendab DataFrame'i transposeerimist ehk ridade ja veergude vahetust ning `rename` meetod lubab veerge nimetada vastavalt eelnevale näitele.
Siin on mõned kõige olulisemad toimingud, mida saame DataFrame'idega teha:
Järgnevalt mõned tähtsamad operatsioonid, mida saame DataFrame'idel sooritada:
**Veergude valik**. Saame valida üksikuid veerge, kirjutades `df['A']` - see operatsioon tagastab Series'i. Samuti saame valida veergude alamhulga teise DataFrame'i, kirjutades `df[['B','A']]` - see tagastab teise DataFrame'i.
**Veergude valik**. Saame valida üksikuid veerge kirjutades `df['A']` - see tagastab Series'i. Võime valida veergude alamkomplekti teise DataFrame'i saamiseks kirjutades `df[['B','A']]` - see annab teise DataFrame'i.
**Filtreerimine** ainult teatud ridade järgi kriteeriumide alusel. Näiteks, et jätta ainult read, kus veerg `A` on suurem kui 5, saame kirjutada`df[df['A']>5]`.
**Ridade filtreerimine** vastavalt tingimustele. Näiteks, et jätta alles ainult read, kus veeru `A` väärtus on suurem kui 5, kirjutame`df[df['A']>5]`.
> **Märkus**: Filtreerimine töötab järgmiselt. Väljend `df['A']<5` tagastab boole'i Series'i, mis näitab, kas väljend on `True` või `False` iga algse Series'i `df['A']` elemendi jaoks. Kui boole'i Series'i kasutatakse indeksina, tagastab see DataFrame'i ridade alamhulga. Seetõttu ei ole võimalik kasutada suvalist Pythoni boole'i väljendit, näiteks kirjutades `df[df['A']>5 and df['A']<7]` oleks vale. Selle asemel peaksite kasutama spetsiaalset `&` operatsiooni boole'i Series'ite peal, kirjutades `df[(df['A']>5) & (df['A']<7)]` (*sulgud on siin olulised*).
> **Märkus**: Filtreerimine töötab järgmiselt. Avaldis `df['A']<5` tagastab tõeväärtusteseeria (boolean series), mis näitab iga algse `df['A']` elemendi kohta, kas avaldis on `True` või `False`. Kui tõeväärtusteseeria on indeksina, tagastab see DataFrame'i ridade alamkogumi. Seetõttu ei saa kasutada suvalist Python'i tõeväärtuslikku avaldist - näiteks `df[df['A']>5 and df['A']<7]` oleks vale. Selle asemel tuleks kasutada spetsiaalset `&` operaatorit tõeväärtusteseeriate vahel, kirjutades `df[(df['A']>5) & (df['A']<7)]` (*hoolitsege sulgude eest*).
**Uute arvutatavate veergude loomine**. Saame hõlpsasti luua uusi arvutatavaid veerge oma DataFrame'ile, kasutades intuitiivset väljendit, näiteks:
**Uute arvutatavate veergude loomine**. Saame hõlpsasti luua DataFrame'i uusi arvutatavaid veerge intuitiivsete avaldiste abil:
```python
df['DivA'] = df['A']-df['A'].mean()
```
See näide arvutab A kõrvalekalde selle keskmisest väärtusest. Tegelikult arvutame siin Series'i ja määrame selle vasakpoolsele küljele, luues uue veeru. Seega ei saa kasutada operatsioone, mis ei ühildu Series'itega, näiteks järgmine kood on vale:
See näide arvutab A hälbe selle keskmisest väärtusest. Tegelikult arvutame series'i ja määrame selle vasakpoolsesse ossa, luues uue veeru. Seetõttu ei saa kasutada operatsioone, mis ei sobi series'iga - näiteks järgmine kood on vale:
```python
# Wrong code -> df['ADescr'] = "Low" if df['A'] <5else"Hi"
df['LenB'] = len(df['B']) # <-Wrong result
# Vale kood -> df['ADescr'] = "Madal" kui df['A'] <5muidu"Kõrge"
df['LenB'] = len(df['B']) # <-Vale tulemus
```
Viimane näide, kuigi süntaktiliselt korrektne, annab meile vale tulemuse, kuna see määrab veeru kõikidele väärtustele Series'i `B` pikkuse, mitte üksikute elementide pikkuse, nagu me kavatsesime.
Viimane näide, kuigi süntaktiliselt korrektne, annab vale tulemuse, sest see määrab veeru kõigile väärtustele `B` pikkuse asemel iga üksiku elemendi pikkuse.
Kui peame arvutama keerukaid väljendeid nagu see, saame kasutada `apply` funktsiooni. Viimane näide võib olla kirjutatud järgmiselt:
Kui vaja arvutada keerukamaid avaldisi, võime kasutada `apply` funktsiooni. Viimane näide on kirjutatav nii:
```python
df['LenB'] = df['B'].apply(lambda x : len(x))
# or
# või
df['LenB'] = df['B'].apply(len)
```
Pärast ülaltoodud toiminguid jõuame järgmise DataFrame'ini:
Ülaltoodud operatsioonide tulemusena saame järgmise DataFrame'i:
| | A | B | DivA | LenB |
| --- | --- | ------ | ---- | ---- |
@ -164,22 +166,22 @@ Pärast ülaltoodud toiminguid jõuame järgmise DataFrame'ini:
| 7 | 8 | very | 3.0 | 4 |
| 8 | 9 | much | 4.0 | 4 |
**Ridade valimine numbrite alusel** saab teha `iloc` konstruktsiooni abil. Näiteks, et valida DataFrame'ist esimesed 5 rida:
**Rea valik numbrite järgi** on tehtav `iloc` konstruktsiooni abil. Näiteks esimese 5 rea valimiseks DataFrame'ist:
```python
df.iloc[:5]
```
**Grupeerimine** kasutatakse sageli tulemuse saamiseks, mis sarnaneb *pivot-tabelitega* Excelis. Oletame, et soovime arvutada veeru `A` keskmise väärtuse iga antud `LenB` numbri jaoks. Siis saame oma DataFrame'i grupeerida `LenB` järgi ja kutsuda `mean`:
**Rühmitamine** kasutatakse sageli tulemuste saamiseks, mis sarnanevad Exceli pöörd- või ristsummatabelitega. Oletame, et soovime arvutada veeru `A` keskmise väärtuse iga `LenB` väärtuse jaoks. Sel juhul rühmitame DataFrame'i `LenB` kaupa ja kutsume `mean` funktsiooni:
```python
df.groupby(by='LenB')[['A','DivA']].mean()
```
Kui peame arvutama keskmise ja elementide arvu grupis, siis saame kasutada keerukamat `aggregate` funktsiooni:
Kui soovime arvutada nii keskmist kui ka grupi elementide arvu, saame kasutada keerulisemat `aggregate` funktsiooni:
@ -190,92 +192,97 @@ See annab meile järgmise tabeli:
| 6 | 2 | 6.000000 |
### Andmete hankimine
Oleme näinud, kui lihtne on luua Series ja DataFrame'i Python objektidest. Kuid tavaliselt on andmed tekstifaili või Exceli tabeli kujul. Õnneks pakub Pandas meile lihtsat viisi andmete laadimiseks kettalt. Näiteks CSV-faili lugemine on nii lihtne:
Oleme näinud, kui lihtne on luua Series ja DataFrame’id Python objektidest. Andmed tulevad aga tavaliselt tekstifaili või Exceli tabeli kujul. Õnneks pakub Pandas lihtsat moodust andmete laadimiseks kettalt. Näiteks CSV faili lugemine on sedavõrd lihtne:
```python
df = pd.read_csv('file.csv')
```
Näeme rohkem näiteid andmete laadimisest, sealhulgas nende hankimist välisveebilehtedelt, "Väljakutse" sektsioonis.
Veel näiteid andmete laadimisest, sealhulgas nende allalaadimisest väljastpoolt veebisaidilt, näeme jaotises "Challenge"
### Andmete kuvamine ja visualiseerimine
### Trükkimine ja joonistamine
Andmeteadlane peab sageli andmeid uurima, seega on oluline osata neid visualiseerida. Kui DataFrame on suur, tahame tihti lihtsalt veenduda, et teeme kõik õigesti, kuvades esimesed paar rida. Seda saab teha, kutsudes `df.head()`. Kui käitate seda Jupyter Notebookis, kuvab see DataFrame'i kenasti tabeli kujul.
Andmeteadlane peab tihti andmeid uurima, seega on oluline neid visualiseerida. Kui DataFrame on suur, tahame tihti lihtsalt veenduda, et kõik on tehtud õigesti, trükkides välja esimesed read. Selleks kutsutakse `df.head()`. Kui kasutate Jupyter Notebooki, trükitakse DataFrame kena tabelina.
Oleme näinud ka `plot` funktsiooni kasutamist, et visualiseerida mõningaid veerge. Kuigi `plot` on väga kasulik paljude ülesannete jaoks ja toetab erinevaid graafikutüüpe `kind=` parameetri kaudu, saate alati kasutada `matplotlib` teeki, et luua midagi keerukamat. Käsitleme andmete visualiseerimist üksikasjalikult eraldi kursuse tundides.
Oleme näinud ka `plot` funktsiooni kasutamist veergude visualiseerimiseks. Kuigi `plot` on paljuülesannetes väga kasulik ning toetab paljusid graafikutüüpe läbi `kind=` parameetri, saate alati kasutada ka puhtalt `matplotlib` teeki keerukamate jooniste tegemiseks. Andmete visualiseerimist käsitleme põhjalikumalt eraldi kursuse õppetundides.
See ülevaade hõlmab Pandase kõige olulisemaid kontseptsioone, kuid teek on väga rikkalik ja võimalused on piiritud! Rakendame nüüd seda teadmist konkreetse probleemi lahendamiseks.
See ülevaade katab Pandase olulisemad mõisted, kuid teek on väga mahukas ja võimalused peaaegu piiramatud! Rakendame nüüd seda teadmist konkreetse probleemi lahendamiseks.
## 🚀 Väljakutse 1: COVID leviku analüüs
Esimene probleem, millele keskendume, on COVID-19 epideemia leviku modelleerimine. Selleks kasutame andmeid nakatunud inimeste arvu kohta erinevates riikides, mida pakub [Center for Systems Science and Engineering](https://systems.jhu.edu/) (CSSE) [Johns Hopkinsi Ülikoolist](https://jhu.edu/). Andmestik on saadaval [selles GitHubi repositooriumis](https://github.com/CSSEGISandData/COVID-19).
Esimene probleem on COVID-19 epideemia leviku modelleerimine. Selleks kasutame nakkusjuhtumite arvu andmeid erinevates riikides, mida pakub [Center for Systems Science and Engineering](https://systems.jhu.edu/) (CSSE) [Johns Hopkinsi Ülikoolis](https://jhu.edu/). Andmestik on kättesaadav [selles GitHubi hoidlas](https://github.com/CSSEGISandData/COVID-19).
Kuna tahame näidata, kuidas andmetega töötada, kutsume teid avama [`notebook-covidspread.ipynb`](notebook-covidspread.ipynb) ja lugema seda algusest lõpuni. Võite ka rakke käivitada ja lahendada mõned väljakutsed, mille oleme teile lõppu jätnud.
Kuna tahame demonstreerida, kuidas andmetega töötada, kutsume teid avama [`notebook-covidspread.ipynb`](notebook-covidspread.ipynb) ja lugema seda põhjalikult. Samuti saate teostada lahtrite käivitamist ja proovida paar väljakutset, mille oleme teile lõppu jätnud.
> Kui te ei tea, kuidas Jupyter Notebookis koodi käivitada, vaadake [seda artiklit](https://soshnikov.com/education/how-to-execute-notebooks-from-github/).
## Töötamine struktureerimata andmetega
Kuigi andmed on sageli tabeli kujul, peame mõnel juhul töötama vähem struktureeritud andmetega, näiteks tekstide või piltidega. Sellisel juhul, et rakendada andmetöötlustehnikaid, mida oleme näinud, peame kuidagi **ekstraheerima** struktureeritud andmeid. Siin on mõned näited:
Kuigi andmed tulevad väga sageli tabelina, peame mõnikord tegelema vähem struktureeritud andmetega, näiteks tekstide või piltidega. Sellisel juhul, et kasutada andmetöötlusmeetodeid, mida oleme ülal näinud, peame kuidagi **ekstraheerima** struktureeritud andmed. Siin on mõned näited:
* Märksõnade ekstraheerimine tekstist ja nende esinemissageduse analüüs
* Neuraalvõrkude kasutamine, et tuvastada objektid pildil
* Emotsioonide tuvastamine videokaamera voogudes
* Neuraalvõrkude kasutamine objektide info ekstraheerimiseks piltidelt
* Emotsioonide tuvastamine inimeste kohta videosalvestusel
Selles väljakutses jätkame COVID pandeemia teemaga ja keskendume teadusartiklite töötlemisele. Olemas on [CORD-19 andmestik](https://www.kaggle.com/allen-institute-for-ai/CORD-19-research-challenge), mis sisaldab üle 7000 (kirjutamise ajal) COVID-teemalist artiklit koos metaandmete ja kokkuvõtetega (ja umbes pooltel juhtudel on saadaval ka täistekstid).
Selles väljakutses jätkame COVID pandeemia teemaga ja keskendume teadusartiklite töötlemisele sellel teemal. Olemas on [CORD-19 andmestik](https://www.kaggle.com/allen-institute-for-ai/CORD-19-research-challenge), mis sisaldab rohkem kui 7000 (kirjutamise hetkel) COVIDi kohta artiklit koos metaandmete ja kokkuvõtetega (ja umbes poole artiklite puhul ka täisteksti).
Täielik näide selle andmestiku analüüsimisest, kasutades [Text Analytics for Health](https://docs.microsoft.com/azure/cognitive-services/text-analytics/how-tos/text-analytics-for-health/?WT.mc_id=academic-77958-bethanycheum) kognitiivset teenust, on kirjeldatud [selles blogipostituses](https://soshnikov.com/science/analyzing-medical-papers-with-azure-and-text-analytics-for-health/). Arutame selle analüüsi lihtsustatud versiooni.
Näide selle andmekogumi analüüsimisest kasutades [Text Analytics for Health](https://docs.microsoft.com/azure/cognitive-services/text-analytics/how-tos/text-analytics-for-health/?WT.mc_id=academic-77958-bethanycheum) kognitiivset teenust on kirjeldatud [selles blogipostituses](https://soshnikov.com/science/analyzing-medical-papers-with-azure-and-text-analytics-for-health/). Me käsitleme selle analüüsi lihtsustatud versiooni.
> **NOTE**: Me ei paku selle repositooriumi osana andmestiku koopiat. Võite esmalt alla laadida [`metadata.csv`](https://www.kaggle.com/allen-institute-for-ai/CORD-19-research-challenge?select=metadata.csv) faili [sellest Kaggle andmestikust](https://www.kaggle.com/allen-institute-for-ai/CORD-19-research-challenge). Registreerimine Kaggle'is võib olla vajalik. Võite andmestiku alla laadida ka ilma registreerimiseta [siit](https://ai2-semanticscholar-cord-19.s3-us-west-2.amazonaws.com/historical_releases.html), kuid see sisaldab kõiki täistekste lisaks metaandmete failile.
> **MÄRKUS**: Me ei paku selle hoidla osana andmestiku koopiat. Võite esmalt alla laadida [`metadata.csv`](https://www.kaggle.com/allen-institute-for-ai/CORD-19-research-challenge?select=metadata.csv) faili [selle andmestiku lehelt Kaggle’is](https://www.kaggle.com/allen-institute-for-ai/CORD-19-research-challenge). Võib-olla peate registreeruma Kaggle’is. Andmestikku saab registreerumiseta alla laadida ka [siit](https://ai2-semanticscholar-cord-19.s3-us-west-2.amazonaws.com/historical_releases.html), kuid seal on lisaks metaandmetele ka kõik täistekstid.
Avage [`notebook-papers.ipynb`](notebook-papers.ipynb) ja lugege seda algusest lõpuni. Võite ka rakke käivitada ja lahendada mõned väljakutsed, mille oleme teile lõppu jätnud.
Avage [`notebook-papers.ipynb`](notebook-papers.ipynb) ja lugege see põhjalikult läbi. Samuti saate käivitada lahtrid ja katsetada mõningaid teile jäetud väljakutseid lõpus.
## Pildiandmete töötlemine
## Pildiadmete töötlemine
Viimasel ajal on välja töötatud väga võimsad AI mudelid, mis võimaldavad meil pilte mõista. Paljusid ülesandeid saab lahendada eelnevalt treenitud neuraalvõrkude või pilveteenuste abil. Mõned näited hõlmavad:
Hiljuti on arendatud väga võimsaid tehisintellekti mudeleid, mis aitavad meil pilte mõista. Paljud ülesanded lahendatakse eelnevalt treenitud neuraalvõrkude või pilveteenuste abil. Mõned näited:
* **Pildiklassifikatsioon**, mis aitab teil kategoriseerida pilti ühte eelnevalt määratletud klassi. Oma pildiklassifikaatorite treenimine on lihtne, kasutades teenuseid nagu [Custom Vision](https://azure.microsoft.com/services/cognitive-services/custom-vision-service/?WT.mc_id=academic-77958-bethanycheum).
* **Objektide tuvastamine**, et tuvastada erinevaid objekte pildil. Teenused nagu [computer vision](https://azure.microsoft.com/services/cognitive-services/computer-vision/?WT.mc_id=academic-77958-bethanycheum) suudavad tuvastada mitmeid levinud objekte, ja saate treenida [Custom Vision](https://azure.microsoft.com/services/cognitive-services/custom-vision-service/?WT.mc_id=academic-77958-bethanycheum) mudelit, et tuvastada konkreetseid huvipakkuvaid objekte.
* **Näotuvastus**, sealhulgas vanuse, soo ja emotsioonide tuvastamine. Seda saab teha [Face API](https://azure.microsoft.com/services/cognitive-services/face/?WT.mc_id=academic-77958-bethanycheum) abil.
* **Pildiklassifikatsioon**, mis aitab kategooriseerida pilti üheks etteantud klassist. Oma pildiklassifikaatoreid saab hõlpsasti treenida teenuste abil, nagu [Custom Vision](https://azure.microsoft.com/services/cognitive-services/custom-vision-service/?WT.mc_id=academic-77958-bethanycheum)
* **Objektituvastus**, mis tuvastab pildil erinevaid objekte. Teenused nagu [computer vision](https://azure.microsoft.com/services/cognitive-services/computer-vision/?WT.mc_id=academic-77958-bethanycheum) tuvastavad hulga levinud objekte, ning [Custom Vision](https://azure.microsoft.com/services/cognitive-services/custom-vision-service/?WT.mc_id=academic-77958-bethanycheum) mudelit saab treenida teatud huvipakkuvate objektide leidmiseks.
* **Nähtuvus** – vanuse, soo ja emotsiooni tuvastamine näolt. Seda saab teha [Face API](https://azure.microsoft.com/services/cognitive-services/face/?WT.mc_id=academic-77958-bethanycheum) abil.
Kõiki neid pilveteenuseid saab kasutada [Python SDK-dega](https://docs.microsoft.com/samples/azure-samples/cognitive-services-python-sdk-samples/cognitive-services-python-sdk-samples/?WT.mc_id=academic-77958-bethanycheum), ja seega saab neid hõlpsasti integreerida teie andmete uurimise töövoogu.
Kõiki neid pilveteenuseid saab kasutada [Python SDK-de](https://docs.microsoft.com/samples/azure-samples/cognitive-services-python-sdk-samples/cognitive-services-python-sdk-samples/?WT.mc_id=academic-77958-bethanycheum) kaudu ning neid on kerge kaasata oma andmeuurimise töövoogu.
Siin on mõned näited pildiandmete allikatest andmete uurimisest:
* Blogipostituses [Kuidas õppida andmeteadust ilma kodeerimiseta](https://soshnikov.com/azure/how-to-learn-data-science-without-coding/) uurime Instagrami fotosid, püüdes mõista, mis paneb inimesi fotole rohkem meeldimisi andma. Esmalt ekstraheerime piltidelt võimalikult palju teavet, kasutades [computer vision](https://azure.microsoft.com/services/cognitive-services/computer-vision/?WT.mc_id=academic-77958-bethanycheum), ja seejärel kasutame [Azure Machine Learning AutoML](https://docs.microsoft.com/azure/machine-learning/concept-automated-ml/?WT.mc_id=academic-77958-bethanycheum), et luua tõlgendatav mudel.
* [Näouuringute töötoas](https://github.com/CloudAdvocacy/FaceStudies) kasutame [Face API](https://azure.microsoft.com/services/cognitive-services/face/?WT.mc_id=academic-77958-bethanycheum), et ekstraheerida emotsioone inimestelt fotodelt üritustelt, püüdes mõista, mis teeb inimesi õnnelikuks.
Siin on mõned näited pildiallikatest andmete uurimisest:
* Blogipostituses [Kuidas õppida andmeteadust ilma kodeerimata](https://soshnikov.com/azure/how-to-learn-data-science-without-coding/) uurime Instagrami fotosid, et mõista, mis paneb inimesi fotot rohkem laikima. Ekstraheerime piltidelt võimalikult palju informatsiooni kasutades [computer vision](https://azure.microsoft.com/services/cognitive-services/computer-vision/?WT.mc_id=academic-77958-bethanycheum) teenust ja seejärel kasutame [Azure Machine Learning AutoML](https://docs.microsoft.com/azure/machine-learning/concept-automated-ml/?WT.mc_id=academic-77958-bethanycheum), et ehitada interpreteeritav mudel.
* [Facial Studies Workshop](https://github.com/CloudAdvocacy/FaceStudies) kasutab [Face API](https://azure.microsoft.com/services/cognitive-services/face/?WT.mc_id=academic-77958-bethanycheum) inimeste emotsioonide ekstraheerimiseks sündmuste ajal tehtud fotodel, et püüda mõista, mis teeb inimesed õnnelikuks.
## Kokkuvõte
Kas teil on juba struktureeritud või struktureerimata andmed, Pythoniga saate teha kõik andmetöötluse ja -mõistmisega seotud sammud. See on tõenäoliselt kõige paindlikum viis andmetöötluseks, ja seetõttu kasutab enamik andmeteadlasi Pythonit oma peamise tööriistana. Pythonit süvitsi õppida on tõenäoliselt hea mõte, kui olete tõsiselt huvitatud oma andmeteaduse teekonnast!
Olenemata sellest, kas sul on struktureeritud või struktureerimata andmed, saad Pythoniga teha kõik andmete töötlemise ja mõistmise sammud. See on tõenäoliselt kõige paindlikum viis andmetöötluseks ja seetõttu kasutab enamus andmeteadlasi just Pythonit esmatööriistana. Python’i süvitsi õppimine on hea mõte, kui oled tõsiselt oma andmeteaduse teekonnaga!
* [Õpi Pythonit lõbusalt Turtle Graphicsi ja fraktalitega](https://github.com/shwars/pycourse)
* [Tee esimesed sammud Pythoniga](https://docs.microsoft.com/learn/paths/python-first-steps/?WT.mc_id=academic-77958-bethanycheum) õpitee [Microsoft Learnis](http://learn.microsoft.com/?WT.mc_id=academic-77958-bethanycheum)
* [Õpi Pythoni lõbusal moel koos kilpkonnagraafika ja fraktaalidega](https://github.com/shwars/pycourse)
* [Astuge esimesed sammud Pythoniga](https://docs.microsoft.com/learn/paths/python-first-steps/?WT.mc_id=academic-77958-bethanycheum) õppeteek Microsoft Learn’is [http://learn.microsoft.com/?WT.mc_id=academic-77958-bethanycheum](http://learn.microsoft.com/?WT.mc_id=academic-77958-bethanycheum)
## Ülesanne
[Tee ülaltoodud väljakutsete kohta põhjalikum andmeuuring](assignment.md)
Selle õppetunni on koostanud ♥️ [Dmitry Soshnikov](http://soshnikov.com)
Selle õppetunni autor on ♥️ [Dmitry Soshnikov](http://soshnikov.com)
---
**Lahtiütlus**:
See dokument on tõlgitud AI tõlketeenuse [Co-op Translator](https://github.com/Azure/co-op-translator) abil. Kuigi püüame tagada täpsust, palume arvestada, et automaatsed tõlked võivad sisaldada vigu või ebatäpsusi. Algne dokument selle algses keeles tuleks pidada autoriteetseks allikaks. Olulise teabe puhul soovitame kasutada professionaalset inimtõlget. Me ei vastuta arusaamatuste või valesti tõlgenduste eest, mis võivad tekkida selle tõlke kasutamise tõttu.
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**Lahtiütlus**:
See dokument on tõlgitud kasutades AI tõlketeenust [Co-op Translator](https://github.com/Azure/co-op-translator). Kuigi me püüdleme täpsuse poole, palun pange tähele, et automatiseeritud tõlgetes võib esineda vigu või ebatäpsusi. Originaaldokument selle emakeeles tuleks pidada autoriteetseks allikaks. Olulise teabe puhul soovitatakse kasutada professionaalset inimtõlget. Me ei vastuta selle tõlkega seotud eksimustest või valesti mõistmistest.
Database dey give beta way to store data and use query language to find am, but di most flexible way to process data na to write your own program wey go manipulate di data. Sometimes, e go better to use database query, but if di data processing wey you wan do dey complex, SQL no go fit handle am well.
Even though databases dey very beta for store data an query dem wit query languages, di most flexible way to process data na to write your own program to manipulate data. For plenty cases, to do query for database go be beta way. But for some cases wey need complex data processing, e no go easy to do am wit SQL.
You fit program data processing for any programming language, but some languages dey more high-level when e come to data work. Data scientists dey mostly dey use one of dis languages:
You fit use any programming language to process data, but some languages dey better for data work. Data scientists dey usually like di following languages:
* **[Python](https://www.python.org/)**, na general-purpose programming language, wey people dey consider as one of di best for beginners because e simple. Python get many libraries wey go fit help you solve plenty practical problems, like how to take data from ZIP archive, or how to convert picture go grayscale. Apart from data science, Python dey also use for web development.
* **[R](https://www.r-project.org/)** na traditional toolbox wey dem build for statistical data processing. E get plenty library repository (CRAN), so e good for data processing. But R no be general-purpose language, and e no too dey use outside data science area.
* **[Julia](https://julialang.org/)** na another language wey dem build specially for data science. E suppose give better performance than Python, so e great for scientific experiment.
* **[Python](https://www.python.org/)**, na general-purpose programming language wey dey simple for beginners. E get plenty extra libraries wey go help you solve different problems, like extracting data from ZIP archive or converting picture to grayscale. Apart from data science, Python dey also useful for web development.
* **[R](https://www.r-project.org/)** na traditional tool wey dem design for statistical data processing. E get big library repository (CRAN), wey make am good for data processing. But R no be general-purpose programming language, and e no dey common outside data science.
* **[Julia](https://julialang.org/)** na language wey dem design for data science. E dey faster than Python, so e dey good for scientific experiments.
For dis lesson, we go focus on how to use Python for simple data processing. We go assume say you get small basic knowledge about the language. If you want explore Python more, you fit check one of these resources:
For dis lesson, we go focus on how to use Python for simple data processing. We go assume say you sabi di basics of di language. If you wan learn Python well, check di following resources:
* [Learn Python in a Fun Way with Turtle Graphics and Fractals](https://github.com/shwars/pycourse) - Quick intro course inside GitHub for Python Programming
* [Take your First Steps with Python](https://docs.microsoft.com/en-us/learn/paths/python-first-steps/?WT.mc_id=academic-77958-bethanycheum) Learning Path for [Microsoft Learn](http://learn.microsoft.com/?WT.mc_id=academic-77958-bethanycheum)
* [Learn Python in a Fun Way with Turtle Graphics and Fractals](https://github.com/shwars/pycourse) - Quick intro course for Python Programming wey dey GitHub
* [Take your First Steps with Python](https://docs.microsoft.com/en-us/learn/paths/python-first-steps/?WT.mc_id=academic-77958-bethanycheum) Learning Path on [Microsoft Learn](http://learn.microsoft.com/?WT.mc_id=academic-77958-bethanycheum)
Data fit get many form. For dis lesson, we go look three forms of data - **tabular data**, **text** an **images**.
Data fit dey in different forms. For dis lesson, we go look three types of data - **tabular data**, **text**, and **images**.
We go focus on some examples of data processing, no be to give you full overview of all libraries. Dis one go help you understand main idea of wetin fit happen, and e go also help you sabi where to find solution to your problems when you need am.
> **Most useful advice**. When you need perform certain operation for data wey you no sabi how to do, try search am for internet. [Stackoverflow](https://stackoverflow.com/) dey normally get plenty useful Python code samples for many common tasks.
We go show small examples of data processing instead of full overview of all di libraries. Dis go help you understand wetin dey possible and where you fit find solutions when you need am.
> **Beta advice**. If you wan do something for data wey you no sabi, search am online. [Stackoverflow](https://stackoverflow.com/) get plenty useful Python code examples for common tasks.
You don already see tabular data when we talk about relational databases. If you get plenty data wey dey inside different linked tables, SQL go make sense to use. But sometimes, you fit get one table of data and you wan understand di data or find insight, like di distribution or correlation between values. For data science, we dey do plenty transformation of original data and visualization. Python dey make dis easy.
You don already meet tabular data when we dey talk about relational databases. When you get plenty data wey dey inside many different linked tables, e make sense to use SQL to work am. But many times we get table of data wey we need understand or get insight about am, like how di data scatter, di relation between di values, and more. For data science, na plenty times we need transform di original data before we fit create visualizations. All these steps easy to do using Python.
Two libraries dey very useful for tabular data in Python:
* **[Pandas](https://pandas.pydata.org/)** dey help you work with **Dataframes**, wey be like relational tables. You fit get named columns and do different operations on rows, columns, and di whole dataframe.
* **[Numpy](https://numpy.org/)** na library for **tensors**, wey be multi-dimensional **arrays**. Arrays dey simpler than dataframes, but e get more mathematical operations and dey faster.
For Python, there two libraries wey fit help you handle tabular data:
* **[Pandas](https://pandas.pydata.org/)** dey allow you manipulate **Dataframes**, wey be like relational tables. Columns fit get names, and you fit do different operations on rows, columns or dataframe generally.
* **[Numpy](https://numpy.org/)** na library wey dey work with **tensors**, that is, multi-dimensional **arrays**. Array get one type of data, e simple pass dataframe, but e fit do plenty mathematical operations and e no get too much overhead.
Other libraries wey you suppose sabi:
You also get some other libraries you suppose sabi:
* **[Matplotlib](https://matplotlib.org/)** na library for data visualization and graph plotting
* **[SciPy](https://www.scipy.org/)** na library for extra scientific functions. We don mention am before when we talk about probability and statistics.
* **[SciPy](https://www.scipy.org/)** na library wey get extra scientific functions. We don already see am when we dey talk about probability an statistics
Dis na example code wey you go use to import di libraries for Python program:
Dis na piece of code wey you go normally use to import dis libraries for start of your Python program:
```python
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy import ... # you need to specify exact sub-packages that you need
from scipy import ... # yu need fo tok di exact sub-packages wey yu need
```
Pandas dey focus on some basic ideas.
### Series
**Series** na sequence of values, like list or numpy array. Di difference be say series get **index**, and when you dey operate on series (like add dem), di index go dey important. Index fit be simple like integer row number (default index for series from list or array), or e fit get complex structure like date interval.
**Series** na sequence of values, like list or numpy array. Di main difference na say series still get **index**, and when you dey do operation on series (like add dem), e dey use di index. Index fit be simple like integer row number (di default index when you create series from list or array), or e fit be complex structure like date interval.
> **Note**: Some introductory Pandas code dey inside di notebook [`notebook.ipynb`](notebook.ipynb) wey dey with this. We go just show some examples small here, but you fit check di full notebook.
> **Note**: Di notebook [`notebook.ipynb`](notebook.ipynb) get small Pandas code wey fit help you. We go show small examples here, but you fit check di full notebook.
Example be say: we wan analyze sales for our ice-cream spot. Make we generate series of sales numbers (number of items wey we sell each day) for some time:
Example: We wan analyze sales for our ice-cream shop. Make we create series of sales numbers (items sold each day) for some time:
```python
start_date = "Jan 1, 2020"
end_date = "Mar 31, 2020"
@ -66,20 +68,20 @@ items_sold.plot()
```
Now, every week we dey do party for friends, and we dey carry extra 10 packs of ice-cream. We fit create another series wey dey indexed by week to show dis:
Now suppose we dey organize party for friends each week, and we carry extra 10 packs ice-cream for di party. We fit create another series, indexed by week, to show dat:
> **Note** say we no use simple syntax `total_items+additional_items`. If we use am, we go get plenty `NaN` (*Not a Number*) values for di result series. Dis na because some index points for `additional_items` series no get values, and adding `NaN` to anything go give `NaN`. So we need to use`fill_value` parameter when we dey add.
> **Note** say we no just use simple code `total_items+additional_items`. If we use dat, we for get plenty `NaN` (*Not a Number*) values for di resulting series. Na because some index points no get value for `additional_items` series, and to add `NaN` to anything go still give `NaN`. So we need specify`fill_value` parameter when we dey add.
For time series, we fit **resample** di series with different time intervals. Example: If we wan calculate monthly mean sales volume, we fit use dis code:
With time series, we fit also **resample** di series for different time intervals. For example, suppose we wan calculate mean sales each month. We fit use dis code:
```python
monthly = total_items.resample("1M").mean()
ax = monthly.plot(kind='bar')
@ -88,23 +90,23 @@ ax = monthly.plot(kind='bar')
### DataFrame
DataFrame na collection of series wey get di same index. We fit join series together to form DataFrame:
DataFrame na collection of series wey get di same index. You fit join plenty series to form one DataFrame:
```python
a = pd.Series(range(1,10))
b = pd.Series(["I","like","to","play","games","and","will","not","change"],index=range(0,9))
Here `.T` na operation to transpose DataFrame, wey dey change rows and columns, and `rename` dey help us rename columns to match di example.
Wen you see `.T` na di transpose operation for DataFrame, dat mean e dey take rows change am to columns and columns to rows, and di `rename` operation fit rename columns to match di previous example.
Some important operations we fit do for DataFrames:
Here na some important operations we fit do on DataFrames:
**Column selection**. We fit select one column with `df['A']` - dis go return Series. We fit also select subset of columns into another DataFrame with `df[['B','A']]`.
**Column selection**. You fit choose individual columns by typing `df['A']` - dis operation return Series. You fit choose some columns make dem go another DataFrame by typing `df[['B','A']]` - dis one return another DataFrame.
**Filtering** rows wey meet criteria. Example: To keep rows wey column `A` dey greater than 5, write `df[df['A']>5]`.
**Filtering** only rows wey meet certain criteria. For example, to keep only rows wey get column `A` greater than 5, you fit write `df[df['A']>5]`.
> **Note**: Filtering dey work like dis. Expression `df['A']<5` go return boolean series wey show if expression na `True` or `False` for each element of original series `df['A']`. Boolean series as index go return subset of rows. You no fit use normal Python boolean expression like `df[df['A']>5 and df['A']<7]`. Instead, use special `&` operation for boolean series, like `df[(df['A']>5) & (df['A']<7)]` (*brackets dey important*).
> **Note**: Filtering dey work like this. The expression `df['A']<5` go return boolean series, weh go show true or false for each element in original series `df['A']`. When boolean series use as index, e go select rows wey true only for the DataFrame. So you no fit use arbitrary Python boolean expression like `df[df['A']>5 and df['A']<7]` because e go wrong. Instead, use special `&` operator for boolean series, like `df[(df['A']>5) & (df['A']<7)]` (*make sure you put brackets correct*).
**Creating new computable columns**. We fit create new columns for DataFrame with simple expression like dis:
**Create new columns wey you fit calculate**. You fit easily create new columns for your DataFrame by writing expression like dis:
```python
df['DivA'] = df['A']-df['A'].mean()
```
Dis example dey calculate divergence of A from mean value. Wetin dey happen be say we dey compute series and assign am to left-hand-side to create new column. So, we no fit use operations wey no work with series, like dis wrong code:
Dis example dey calculate how A differ from its mean. Wetin actually dey happen be say we dey calculate series, then assign am to the left-hand side, to create new column. So no fit use operations wey no fit with series, like dis code below wey no correct:
```python
# Wrong code -> df['ADescr'] = "Low" if df['A'] <5else"Hi"
df['LenB'] = len(df['B']) # <-Wrong result
df['LenB'] = len(df['B']) # <-Result nocorrect
```
Dis example dey wrong because e dey assign di length of series `B` to all values in di column, instead of di length of individual elements.
Dis example, even though e correct for syntax, e no dey correct for result: e assign di length of entire series `B` to all values for di column, no be length of individual elements like we want.
If we wan compute complex expressions, we fit use `apply` function. Di last example fit look like dis:
If you need to compute complex expressions like dis, you fit use `apply` function. Di last example fit write am dis way:
```python
df['LenB'] = df['B'].apply(lambda x : len(x))
# or
# or
df['LenB'] = df['B'].apply(len)
```
After dis operations, we go get DataFrame like dis:
After di operations, di DataFrame go be like dis:
| | A | B | DivA | LenB |
| --- | --- | ------ | ---- | ---- |
@ -164,22 +166,22 @@ After dis operations, we go get DataFrame like dis:
| 7 | 8 | very | 3.0 | 4 |
| 8 | 9 | much | 4.0 | 4 |
**Selecting rows by numbers** fit use `iloc`. Example: To select first 5 rows:
**Select rows based on position** fit do using `iloc`. For example, to choose first 5 rows from DataFrame:
```python
df.iloc[:5]
```
**Grouping** dey useful for result like *pivot tables* for Excel. Example: If we wan calculate mean value of column `A` for each `LenB`, we fit group DataFrame by `LenB` and call `mean`:
**Grouping** dey often used like *pivot tables* for Excel. Suppose we wan calculate mean value of column `A` based on number of `LenB`. Then we go group our DataFrame by `LenB`, and call `mean`:
```python
df.groupby(by='LenB')[['A','DivA']].mean()
```
If we wan calculate mean and count of elements in group, we fit use`aggregate` function:
If you wanna calculate mean and number of elements in each group, fit use complex`aggregate` function:
We don see how e easy to build Series and DataFrames from Python objects. But data dey usually come as text file or Excel table. Luckily, Pandas get simple way wey we fit use load data from disk. For example, to read CSV file na just like this:
We don don see how easy e dey to build Series and DataFrames from Python objects. But, data most times dey come as text file or Excel table. Lucky for us, Pandas get simple way to load data from disk. For example, to read CSV file na like dis e be:
```python
df = pd.read_csv('file.csv')
```
We go see more examples of how to load data, including how to fetch am from external websites, for the "Challenge" section.
We go see more example of how to load data, including to fetch am from external web sites, for the "Challenge" section
### Printing and Plotting
Data Scientist dey always need to explore data, so e dey important to fit visualize am. When DataFrame big, sometimes we just wan confirm say we dey do everything correct by printing the first few rows. You fit do am by calling `df.head()`. If you dey run am from Jupyter Notebook, e go print the DataFrame in better tabular form.
Data Scientist dem dey often need to explore data, so e important to fit visualize am. When DataFrame big, many times we just want to sure say everything dey go well by to print the first few rows. You fit do dis by to run `df.head()`. If you dey run am from Jupyter Notebook, e go print the DataFrame for correct tabular form.
We don also see how to use `plot` function to visualize some columns. Even though `plot`dey very useful for plenty tasks, and e support different graph types with `kind=` parameter, you fit still use raw `matplotlib` library to plot something wey complex pass. We go cover data visualization well for separate course lessons.
We don also see how to use `plot` function to visualize some columns. Even though `plot`good for plenty tasks and e fit support different graph types via `kind=` parameter, you fit always use raw `matplotlib` library to plot something more complex. We go talk about data visualization better for separate course lessons.
This overview don cover the most important Pandas concepts, but the library dey very rich, and e no get limit to wetin you fit do with am! Make we now use this knowledge to solve specific problem.
Dis overview don cover the main concepts wey dey important for Pandas, but the library get plenti tins, and e no get limit for wetin you fit do with am! Now make we use this knowledge do correct solution for specific problem.
## 🚀 Challenge 1: Analyzing COVID Spread
The first problem wey we go focus on na how COVID-19 epidemic dey spread. To do this, we go use data wey show the number of infected people for different countries, wey [Center for Systems Science and Engineering](https://systems.jhu.edu/) (CSSE) for [Johns Hopkins University](https://jhu.edu/) provide. The dataset dey available for [this GitHub Repository](https://github.com/CSSEGISandData/COVID-19).
The first problem we go focus on na how to model the epidemic spread of COVID-19. To do dat, we go use data about infected people for different countries, dat one na from [Center for Systems Science and Engineering](https://systems.jhu.edu/) (CSSE) at [Johns Hopkins University](https://jhu.edu/). The dataset dey for [this GitHub Repository](https://github.com/CSSEGISandData/COVID-19).
Since we wan show how to handle data, we dey invite you to open [`notebook-covidspread.ipynb`](notebook-covidspread.ipynb) and read am from top to bottom. You fit also run the cells, and try some challenges wey we don leave for you for the end.
Since we wan show how to handle data, we dey invite you to open [`notebook-covidspread.ipynb`](notebook-covidspread.ipynb) and read am from top to bottom. You fit also run the cells, and do some challenges wey we leave for you for end.
@ -216,41 +221,41 @@ Since we wan show how to handle data, we dey invite you to open [`notebook-covid
## Working with Unstructured Data
Even though data dey usually come in tabular form, sometimes we need to handle data wey no too structured, like text or images. For this case, to use the data processing techniques we don see before, we need to **extract** structured data. Here be some examples:
Even though data plenty times dey tabular form, sometimes we need deal with less structured data like text or pictures. For dis kain case, to apply data processing techniques we don see before, we need to somehow **extract** structured data. Here na some examples:
* Extract keywords from text, and check how often those keywords dey appear
* Extract keywords from text, and see how often those keywords show face
* Use neural networks to extract information about objects for picture
* Get information about people emotions from video camera feed
* Get information about how people dey feel from video camera feed
## 🚀 Challenge 2: Analyzing COVID Papers
For this challenge, we go continue with the COVID pandemic topic, and focus on how to process scientific papers about the matter. [CORD-19 Dataset](https://www.kaggle.com/allen-institute-for-ai/CORD-19-research-challenge) get over 7000 papers (at the time we dey write this) about COVID, with metadata and abstracts (and for about half of them, full text dey available too).
For dis challenge, we go continue with COVID pandemic topic, and focus on processing scientific papers about am. There dey [CORD-19 Dataset](https://www.kaggle.com/allen-institute-for-ai/CORD-19-research-challenge) wey get more than 7000 papers (like dis time we dey write this one) on COVID, with metadata and abstracts (and about half of them get full text too).
Full example of how to analyze this dataset using [Text Analytics for Health](https://docs.microsoft.com/azure/cognitive-services/text-analytics/how-tos/text-analytics-for-health/?WT.mc_id=academic-77958-bethanycheum) cognitive service dey [this blog post](https://soshnikov.com/science/analyzing-medical-papers-with-azure-and-text-analytics-for-health/). We go discuss simplified version of this analysis.
Full example of how to analyze dis dataset using [Text Analytics for Health](https://docs.microsoft.com/azure/cognitive-services/text-analytics/how-tos/text-analytics-for-health/?WT.mc_id=academic-77958-bethanycheum) cognitive service dey explained [for dis blog post](https://soshnikov.com/science/analyzing-medical-papers-with-azure-and-text-analytics-for-health/). We go talk about simplified version of dis analysis.
> **NOTE**: We no dey provide copy of the dataset for this repository. You go first need to download the [`metadata.csv`](https://www.kaggle.com/allen-institute-for-ai/CORD-19-research-challenge?select=metadata.csv) file from [this dataset on Kaggle](https://www.kaggle.com/allen-institute-for-ai/CORD-19-research-challenge). You fit need to register with Kaggle. You fit also download the dataset without registration [from here](https://ai2-semanticscholar-cord-19.s3-us-west-2.amazonaws.com/historical_releases.html), but e go include all full texts plus metadata file.
> **NOTE**: We no dey provide copy of the dataset for dis repository. You fit first download the [`metadata.csv`](https://www.kaggle.com/allen-institute-for-ai/CORD-19-research-challenge?select=metadata.csv) file from [dis dataset for Kaggle](https://www.kaggle.com/allen-institute-for-ai/CORD-19-research-challenge). You fit need register for Kaggle. You fit also download the dataset without registration [from here](https://ai2-semanticscholar-cord-19.s3-us-west-2.amazonaws.com/historical_releases.html), but e go carry all full texts join metadata file.
Open [`notebook-papers.ipynb`](notebook-papers.ipynb) and read am from top to bottom. You fit also run the cells, and try some challenges wey we don leave for you for the end.
Open [`notebook-papers.ipynb`](notebook-papers.ipynb) and read am from top to bottom. You fit still run cells and do some challenges we leave for you at the end.
## Processing Image Data
Recently, strong AI models don dey wey fit help us understand images. Plenty tasks fit dey solved using pre-trained neural networks or cloud services. Some examples include:
Recently, powerful AI models don show wey to understand images well well. Plenty tasks fit solve by pre-trained neural networks, or cloud services. Some examples na:
* **Image Classification**, wey fit help you categorize image into one of the pre-defined classes. You fit train your own image classifiers easily using services like [Custom Vision](https://azure.microsoft.com/services/cognitive-services/custom-vision-service/?WT.mc_id=academic-77958-bethanycheum)
* **Object Detection** to detect different objects for image. Services like [computer vision](https://azure.microsoft.com/services/cognitive-services/computer-vision/?WT.mc_id=academic-77958-bethanycheum) fit detect plenty common objects, and you fit train [Custom Vision](https://azure.microsoft.com/services/cognitive-services/custom-vision-service/?WT.mc_id=academic-77958-bethanycheum) model to detect specific objects wey you dey interested in.
* **Face Detection**, including Age, Gender and Emotion detection. You fit do this with [Face API](https://azure.microsoft.com/services/cognitive-services/face/?WT.mc_id=academic-77958-bethanycheum).
* **Image Classification**, wey fit help you categorize the image into one of the pre-defined classes. You fit train your own image classifiers easily using services like [Custom Vision](https://azure.microsoft.com/services/cognitive-services/custom-vision-service/?WT.mc_id=academic-77958-bethanycheum)
* **Object Detection** to find different objects for inside the image. Services like [computer vision](https://azure.microsoft.com/services/cognitive-services/computer-vision/?WT.mc_id=academic-77958-bethanycheum) fit detect common objects, and you fit train [Custom Vision](https://azure.microsoft.com/services/cognitive-services/custom-vision-service/?WT.mc_id=academic-77958-bethanycheum) model to detect specific objects wey you fit need.
* **Face Detection**, wey include Age, Gender and Emotion detection. You fit do dis with [Face API](https://azure.microsoft.com/services/cognitive-services/face/?WT.mc_id=academic-77958-bethanycheum).
All these cloud services fit dey called using [Python SDKs](https://docs.microsoft.com/samples/azure-samples/cognitive-services-python-sdk-samples/cognitive-services-python-sdk-samples/?WT.mc_id=academic-77958-bethanycheum), and e fit dey easily added to your data exploration workflow.
All these cloud services you fit call am using [Python SDKs](https://docs.microsoft.com/samples/azure-samples/cognitive-services-python-sdk-samples/cognitive-services-python-sdk-samples/?WT.mc_id=academic-77958-bethanycheum), so e dey easy to put am inside your data exploration workflow.
Here be some examples of how to explore data from Image data sources:
* For the blog post [How to Learn Data Science without Coding](https://soshnikov.com/azure/how-to-learn-data-science-without-coding/) we dey explore Instagram photos, dey try understand wetin dey make people like photo more. We first extract as much information from pictures as we fit using [computer vision](https://azure.microsoft.com/services/cognitive-services/computer-vision/?WT.mc_id=academic-77958-bethanycheum), then use [Azure Machine Learning AutoML](https://docs.microsoft.com/azure/machine-learning/concept-automated-ml/?WT.mc_id=academic-77958-bethanycheum) to build interpretable model.
* For [Facial Studies Workshop](https://github.com/CloudAdvocacy/FaceStudies) we dey use [Face API](https://azure.microsoft.com/services/cognitive-services/face/?WT.mc_id=academic-77958-bethanycheum) to extract emotions from people for photos from events, to try understand wetin dey make people happy.
Here na some examples of how to explore data from Image data sources:
* For blog post [How to Learn Data Science without Coding](https://soshnikov.com/azure/how-to-learn-data-science-without-coding/) we explore Instagram photos, to sabi why people dey give more likes for photo. First, we extract as much information as e possible from pictures using [computer vision](https://azure.microsoft.com/services/cognitive-services/computer-vision/?WT.mc_id=academic-77958-bethanycheum), then use [Azure Machine Learning AutoML](https://docs.microsoft.com/azure/machine-learning/concept-automated-ml/?WT.mc_id=academic-77958-bethanycheum) to build model wey fit explain well.
* For [Facial Studies Workshop](https://github.com/CloudAdvocacy/FaceStudies) we dey use [Face API](https://azure.microsoft.com/services/cognitive-services/face/?WT.mc_id=academic-77958-bethanycheum) to extract emotional expressions for people dem wey dey picture from events, to try understand wetin dey make people happy.
## Conclusion
Whether you get structured or unstructured data, using Python you fit do all steps wey concern data processing and understanding. Python na probably the most flexible way to process data, and na why most data scientists dey use Python as their main tool. To learn Python well well na good idea if you serious about your data science journey!
Whether your data structured or no structured, if you get Python you fit do all the data processing and understanding steps. E dey probably the most flexible way for data processing, and na why many data scientists dey use Python as their primary tool. To learn Python well no be small thing if you serious about your data science journey!
@ -265,19 +270,19 @@ Whether you get structured or unstructured data, using Python you fit do all ste
**Learning Python**
* [Learn Python in a Fun Way with Turtle Graphics and Fractals](https://github.com/shwars/pycourse)
* [Take your First Steps with Python](https://docs.microsoft.com/learn/paths/python-first-steps/?WT.mc_id=academic-77958-bethanycheum) Learning Path on [Microsoft Learn](http://learn.microsoft.com/?WT.mc_id=academic-77958-bethanycheum)
* [Take your First Steps with Python](https://docs.microsoft.com/learn/paths/python-first-steps/?WT.mc_id=academic-77958-bethanycheum) Learning Path for [Microsoft Learn](http://learn.microsoft.com/?WT.mc_id=academic-77958-bethanycheum)
## Assignment
[Perform more detailed data study for the challenges above](assignment.md)
[Do more detailed data study for the challenges wey dey top](assignment.md)
## Credits
This lesson don dey authored with ♥️ by [Dmitry Soshnikov](http://soshnikov.com)
Dis lesson dem write am wit ♥️ by [Dmitry Soshnikov](http://soshnikov.com)
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**Disclaimer**:
Dis document don dey translate wit AI translation service [Co-op Translator](https://github.com/Azure/co-op-translator). Even though we dey try make am accurate, abeg sabi say automated translations fit get mistake or no dey 100% correct. Di original document for di native language na di main correct source. For important information, e better make una use professional human translation. We no go fit take blame for any misunderstanding or wrong interpretation wey fit happen because of dis translation.
**Disclaimer**:
Dis document don translate wit AI translation service [Co-op Translator](https://github.com/Azure/co-op-translator). Even tho we dey try make am correct, abeg make you know say automated translation fit get errors or mistakes. Di original document for dia own language na im be di correct source. For important info, make person wey sabi human translation do am. We no go responsible for any misunderstanding or wrong understanding wey fit happen because of dis translation.
தரவுகளை சேமிக்கவும், கேள்வி மொழிகளைப் பயன்படுத்தி அவற்றை கேள்வி கேட்கவும் தரவுத்தொகுப்புகள் மிகவும் திறமையான வழிகளை வழங்குகின்றன. ஆனால், தரவுகளை செயலாக்குவதற்கான மிகவும் நெகிழ்வான வழி, உங்கள் சொந்த நிரல்களை எழுதுவதுதான். பல சந்தர்ப்பங்களில், தரவுத்தொகுப்பில் கேள்வி கேட்பது மிகவும் பயனுள்ளதாக இருக்கும். ஆனால் சில நேரங்களில், SQL மூலம் எளிதாக செய்ய முடியாத சிக்கலான தரவுச் செயலாக்கம் தேவைப்படும் போது, உங்கள் சொந்த நிரல்களை எழுதுவது சிறந்த தேர்வாக இருக்கும்.
தரவுத்தளங்கள் தரவை சேமிக்கவும் கேள்விப்படிகளை செய்முறை மொழிகளைக் கொண்டு கேட்கவும் மிகவும் திறமையான வழிகளை வழங்கினாலும், தரவை கையாள வேண்டிய மிக தாழ்வான மற்றும் சுதந்திரமான வழி உங்கள் சொந்தத் திட்டத்தை எழுதி அதன் மூலம் தரவை செயலாக்குதலே ஆகும். பல சூழல்களில், தரவுத்தளக் கேள்வி செய்வது பலவீனமான வழியாக இருக்கும். ஆனால் சிலச் சூழல்களில், அதிக சிக்கலான தரவு செயலாக்கம் தேவைப்படும் போது அது எளிதில் SQL கொண்டு செய்ய முடியாது.
தரவு செயலாக்கத்தை எந்தத் திட்டமிடல் மொழியிலும் எழுத இயலும், ஆனால் தரவுடன் வேலை செய்வதில் குறிப்பாக மேல்நிலை பிரிவுகளில் சில மொழிகள் உள்ளன. தரவியல் விஞ்ஞானிகள் பொதுவாக பின்வரும் மொழிகளில் ஒன்றைப் பயன்படுத்த விரும்புகிறார்கள்:
தரவுச் செயலாக்கத்தை எந்த நிரலாக்க மொழியிலும் செய்யலாம், ஆனால் சில மொழிகள் தரவுடன் வேலை செய்வதில் உயர்ந்த நிலையைப் பெற்றுள்ளன. தரவியல் விஞ்ஞானிகள் பொதுவாக பின்வரும் மொழிகளில் ஒன்றை விரும்புகிறார்கள்:
* **[Python](https://www.python.org/)**, பொதுவான பயன்பாட்டிற்கான திட்டமிடல் மொழி, அதன் எளிய தன்மையால் ஆரம்பிகளுக்கு சிறந்த விருப்பங்களில் ஒன்று என கருதப்படுகிறது. Python க்கு பல கூடுதல் நூலகங்கள் உள்ளன, அவை உங்கள் தரவு ZIP ஆர்கைவிலிருந்து எடுக்க உதவாது மட்டுமல்ல, படத்தை கிரேஸ்கேல் மாற்றவும் உதவுகின்றன. தரவைப் பற்றிய அறிவியலை தவிர Python வலை கோப்புரத்திலும் பெரிதும் பயன்படுத்தப்படுகிறது.
* **[R](https://www.r-project.org/)** என்பது பாரம்பரியமான பெட்டி, புள்ளியியல் தரவு செயலாக்கத்தை மனதில் வைத்து உருவாக்கப்பட்டது. அதிலும் பெரிய நூலக சேமிப்பகம் (CRAN) உள்ளது, இது தரவு செயலாக்கத்திற்கு நல்ல தேர்வு ஆகும். ஆனால் R என்பது பொதுவான பயன்பாட்டுக்கான திட்டமிடல் மொழி அல்ல, மற்றும் தரவியல் துறைக்கு வெளியே அரிதாகப் பயன்படுத்தப்படுகிறது.
* **[Julia](https://julialang.org/)** மற்றொரு மொழி தான் தரவியல் அறிவியலுக்காக குறிப்பாக உருவாக்கப்பட்டது. இது Python விட சிறப்பு செயல்திறனைக் கொடுப்பதற்காக திட்டமிடப்பட்டது, அறிவியல் பரிசோதனைகளுக்கான சிறந்த கருவியாகும்.
* **[Python](https://www.python.org/)**, ஒரு பொதுவான பயன்பாட்டு நிரலாக்க மொழி, அதன் எளிமையால் தொடக்கநிலை பயிற்சியாளர்களுக்கு சிறந்த தேர்வாக கருதப்படுகிறது. Python பல கூடுதல் நூலகங்களை கொண்டுள்ளது, இது ZIP காப்பகத்திலிருந்து உங்கள் தரவுகளை எடுக்க அல்லது படத்தை grayscale-ஆக மாற்ற போன்ற பல நடைமுறை பிரச்சனைகளைத் தீர்க்க உதவுகிறது. தரவியல் விஞ்ஞானத்துடன், Python வலை வளர்ச்சிக்காகவும் பரவலாக பயன்படுத்தப்படுகிறது.
* **[R](https://www.r-project.org/)** என்பது புள்ளிவிவர தரவுச் செயலாக்கத்திற்காக உருவாக்கப்பட்ட பாரம்பரிய கருவியாகும். இது பெரிய நூலகக் களஞ்சியத்தை (CRAN) கொண்டுள்ளது, இது தரவுச் செயலாக்கத்திற்கு நல்ல தேர்வாகும். ஆனால், R ஒரு பொதுவான பயன்பாட்டு நிரலாக்க மொழி அல்ல, மேலும் தரவியல் விஞ்ஞானத் துறைக்கு வெளியே அரிதாகவே பயன்படுத்தப்படுகிறது.
* **[Julia](https://julialang.org/)** என்பது தரவியல் விஞ்ஞானத்திற்காகவே உருவாக்கப்பட்ட மற்றொரு மொழியாகும். Python-ஐ விட சிறந்த செயல்திறனை வழங்குவதற்காக இது உருவாக்கப்பட்டுள்ளது, இது அறிவியல் பரிசோதனைகளுக்கு சிறந்த கருவியாகும்.
இந்த பாடத்தில், எளிய தரவு செயலாக்கத்திற்கு Python பயன்படுத்துவதை கவனித்துக் கொள்ளப்போகிறோம். மொழியில் அடிப்படையான பரிச்சயத்தை கொண்டதாக நினைக்கிறோம். Python இன் விரிவான பயணத்திற்கு கீழ்க்காணும் ஆதாரங்களைப் பார்க்கலாம்:
இந்த பாடத்தில், எளிய தரவுச் செயலாக்கத்திற்காக Python-ஐப் பயன்படுத்துவதில் கவனம் செலுத்துவோம். மொழியின் அடிப்படை அறிமுகம் உங்களிடம் உள்ளது என்று கருதுகிறோம். Python-ஐப் பற்றிய ஆழமான பயணத்தை விரும்பினால், பின்வரும் வளங்களைப் பார்க்கலாம்:
* [Turtle Graphics மற்றும் Fractals உடன் Python கற்றுக்கொள்ளவும்](https://github.com/shwars/pycourse) - GitHub அடிப்படையிலான உரைந்த அறிமுகப் பாடவியல்
* [Python உடன் உங்கள் முதல் படிகளை எடுக்கவும்](https://docs.microsoft.com/en-us/learn/paths/python-first-steps/?WT.mc_id=academic-77958-bethanycheum) [Microsoft Learn](http://learn.microsoft.com/?WT.mc_id=academic-77958-bethanycheum) இல் கற்றல் பாதை
* [Learn Python in a Fun Way with Turtle Graphics and Fractals](https://github.com/shwars/pycourse) - Python நிரலாக்கத்திற்கான GitHub அடிப்படையிலான விரைவான அறிமுகப் பாடநெறி
* [Take your First Steps with Python](https://docs.microsoft.com/en-us/learn/paths/python-first-steps/?WT.mc_id=academic-77958-bethanycheum) [Microsoft Learn](http://learn.microsoft.com/?WT.mc_id=academic-77958-bethanycheum) இல் உள்ள கற்றல் பாதை
தரவுகள் பல்வேறு வடிவங்களில் இருக்க முடியும். இந்தக் பாடத்தில், நாம் மூன்று தரவு வடிவங்களைப் பார்க்கப்போகிறோம் - **அட்டவணைத் தரவு**, **உரை** மற்றும் **படங்கள்**.
தரவு பல வடிவங்களில் வரலாம். இந்த பாடத்தில், மூன்று தரவுப் வடிவங்களைப் பரிசீலிப்போம் - **அட்டவணை தரவு**, **உரை** மற்றும் **படங்கள்**.
நாம் பல இணைப்புகளைக் கொடுப்பதற்குப் பதிலாக சில தரவு செயலாக்க உதாரணங்களுக்கே கவனம் செலுத்தப்போகிறோம். இது நீங்கள் என்ன செய்யக்கூடியது என்பதைப் புரிந்துகொள்ள உதவுகிறது மற்றும் உங்கள் பிரச்சினைகளுக்கு தீர்வுகளை எங்கே காண்பது என்பதைக் கற்றுக்கொள்ள உதவும்.
நாம் தொடர்புடைய அனைத்து நூலகங்களின் முழு கண்ணோட்டத்தை வழங்காமல், சில தரவுச் செயலாக்க உதாரணங்களில் கவனம் செலுத்துவோம். இது என்ன செய்ய முடியும் என்பதற்கான முக்கியமான கருத்தை உங்களுக்கு வழங்கும், மேலும் உங்களுக்கு தேவையான போது உங்கள் பிரச்சனைகளுக்கான தீர்வுகளை எங்கு தேட வேண்டும் என்பதற்கான புரிதலை உங்களுக்கு வழங்கும்.
> **மிகவும் பயனுள்ள ஆலோசனை**. நீங்கள் செய்யவேண்டிய குறிப்பிட்ட செயல்பாட்டை நீங்கள் எப்படி செய்யமுடியும் எனப் தெரியாவிட்டால், அதை இணையத்தில் தேட முயலுங்கள். [Stackoverflow](https://stackoverflow.com/) பைத்தான் பல வழக்கமான பணிகளுக்கான பல பயனுள்ள குறியீடு உதாரணங்களை வழங்குகிறது.
> **மிகவும் பயனுள்ள ஆலோசனை**: நீங்கள் செய்ய வேண்டிய ஒரு குறிப்பிட்ட செயல்பாட்டை எப்படி செய்வது என்று தெரியவில்லை என்றால், அதை இணையத்தில் தேட முயற்சிக்கவும். [Stackoverflow](https://stackoverflow.com/) பல பொதுவான பணிகளுக்கான Python குறியீட்டு மாதிரிகளை அடிக்கடி கொண்டுள்ளது.
## [பாடத்துக்கு முன் வினாடி வினா](https://ff-quizzes.netlify.app/en/ds/quiz/12)
நீங்கள் தொடர்புடைய தரவுத்தொகுப்புகளைப் பற்றி பேசும்போது அட்டவணை தரவுகளை ஏற்கனவே சந்தித்துள்ளீர்கள். உங்களிடம் அதிக அளவிலான தரவுகள் உள்ளன, மேலும் அவை பல்வேறு இணைக்கப்பட்ட அட்டவணைகளில் உள்ளன, SQL-ஐப் பயன்படுத்துவது மிகவும் பொருத்தமானதாக இருக்கும். ஆனால், பல சந்தர்ப்பங்களில், ஒரு அட்டவணை தரவுடன் நாம் **புரிதல்** அல்லது **உள்ளடக்கம்** பெற வேண்டும், உதாரணமாக விநியோகம், மதிப்புகளுக்கிடையிலான தொடர்பு போன்றவை. தரவியல் விஞ்ஞானத்தில், அசல் தரவின் சில மாற்றங்களைச் செய்ய வேண்டும், அதற்குப் பிறகு காட்சிப்படுத்தல் செய்ய வேண்டும். Python-ஐப் பயன்படுத்தி இந்த இரண்டு படிகளையும் எளிதாக செய்யலாம்.
நாம் தொடர்புடைய தரவுத்தளங்களை பற்றி பேசும்போது நீங்களே அட்டவணை தரவுடன் சந்தித்திருக்கிறீர்கள். பெரிய தரவுகள் பல இணைக்கப்பட்ட அட்டவணைகளில் இருக்கும் போது, SQL பயன்படுத்துவது உண்மையில் நல்லது. ஆனால் பல சந்தர்ப்பங்களில், நாம் தரவு அட்டவணையைப் பெற்றிருக்கிறோம், அதைக் கொண்டு நாம் சில **புரிதல்கள்** அல்லது **உள்ளடக்கங்கள்** பெற வேண்டும், உதாரணமாக விநியோகம், மதிப்புகளுக்கிடையேயான தொடர்பு போன்றவை. தரவியல் அறிவியலில், பலவித சந்தர்புகளில் மூல தரவுகளில் மாற்றங்களைச் செய்து, பின்னர் காட்சிப்படுத்துதலுக்குப் பிறகு செய்வது தேவையானது. இந்த இரு படிகள் Python கொண்டு எளிதாக செய்யக்கூடியவை.
Python-இல் அட்டவணை தரவுகளைச் சமாளிக்க உதவக்கூடிய இரண்டு மிகவும் பயனுள்ள நூலகங்கள் உள்ளன:
* **[Pandas](https://pandas.pydata.org/)**, **Dataframes**-ஐ மாற்றுவதற்கு அனுமதிக்கிறது, இது தொடர்புடைய அட்டவணைகளுக்கு ஒத்ததாகும். நீங்கள் பெயரிடப்பட்ட நெடுவரிசைகளைப் பெறலாம், மேலும் வரிசைகள், நெடுவரிசைகள் மற்றும் Dataframes-களில் பல்வேறு செயல்பாடுகளைச் செய்யலாம்.
* **[Numpy](https://numpy.org/)**, **tensors**, அதாவது பல-பரிமாண **arrays**-களுடன் வேலை செய்யும் நூலகமாகும். Array ஒரே அடிப்படை வகையின் மதிப்புகளை கொண்டுள்ளது, மேலும் இது dataframe-ஐ விட எளிமையானது, ஆனால் இது அதிக கணித செயல்பாடுகளை வழங்குகிறது மற்றும் குறைவான overhead-ஐ உருவாக்குகிறது.
Python இல் அட்டவணை தரவை கையாள உதவும் முக்கியமான இரண்டு நூலகங்கள் உள்ளன:
* **[Pandas](https://pandas.pydata.org/)** என்பது **Dataframes** எனப்படும் அவற்றின் அட்டைத் தொழில்நுட்ப அட்டவணைகளுக்குச் சமமானவற்றை கையாள உதவுகிறது. நீங்கள் பெயரிடப்பட்ட நெடுவரிசைகள் வைத்துக் கொள்ளலாம் மற்றும் வரிசை, நெடுவரிசை மற்றும் Dataframes இல் பொதுவாக வெவ்வேறு பணிகளை செய்யலாம்.
* **[Numpy](https://numpy.org/)** என்பது **tensors** அல்லது பல பரிமாண **அறை** வுகளை கையாளும் நூலகம். அறைகளில் அனைத்தும் ஒரே வகையான தரவுகளைக் கொண்டிருக்கும், இது dataframe உங்கள் தொழில்நுட்பத்தை விட எளிமையானதாக இருப்பது போல, ஆனால் அதிக கணித செயலாக்கவையும் குறைவான நெருக்கடியையும் அளிக்கிறது.
நீங்கள் தெரிந்திருக்க வேண்டிய மற்ற சில நூலகங்கள்:
* **[Matplotlib](https://matplotlib.org/)**, தரவுக் காட்சிப்படுத்தல் மற்றும் வரைபடங்களை வரைதல் செய்ய பயன்படும் நூலகம்
* **[SciPy](https://www.scipy.org/)**, சில கூடுதல் அறிவியல் செயல்பாடுகளைக் கொண்ட நூலகம். ப вероятத்திற்கும் புள்ளிவிவரங்களுக்கும் தொடர்புடைய போது நாம் ஏற்கனவே இந்த நூலகத்தை சந்தித்துள்ளோம்.
நீங்கள் அறிந்திருக்க வேண்டிய மற்ற சில நூலகங்களும் உள்ளன:
* **[Matplotlib](https://matplotlib.org/)** என்பது தரவு காட்சி மற்றும் வரைபடங்களை வரைதல் பயன்படுத்தப்படும் நூலகம்
* **[SciPy](https://www.scipy.org/)** என்பது கூடுதலான அறிவியல் செயல்பாடுகளை கொண்ட நூலகம். நாம் முன்னர் இது பற்றி புள்ளியியல் மற்றும் அபாயத்தைப் பேசும்போது சந்தித்தோம்
Python நிரலின் தொடக்கத்தில் இந்த நூலகங்களை இறக்குமதி செய்ய நீங்கள் பொதுவாக பயன்படுத்தும் குறியீடு இங்கே:
Python திட்டத்தின் ஆரம்பத்தில் கீழ்காணும் குறியீடு மூலம் நாம் இந்நூலகங்களை இறக்குமதி செய்கிறோம்:
```python
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy import ... # you need to specify exact sub-packages that you need
from scipy import ... # நீங்கள் தேவையான சரியான துணை-பெகேஜ்களை குறிப்பிட வேண்டும்
```
Pandas சில அடிப்படை கருத்துகளின் மீது மையமாக உள்ளது.
Pandas இல் சில அடிப்படை பார்வைகள் உள்ளன.
### Series
### வரிசைகள் (Series)
**Series** என்பது மதிப்புகளின் வரிசையாகும், இது ஒரு பட்டியல் அல்லது numpy array-க்கு ஒத்ததாகும். முக்கியமான வேறுபாடு என்னவென்றால், series-க்கு **index** உள்ளது, மேலும் series-களில் செயல்படும்போது (எ.கா., அவற்றைச் சேர்க்கும்போது), index கணக்கில் எடுத்துக்கொள்ளப்படுகிறது. Index எளிய integer வரிசை எண்ணாக இருக்கலாம் (இது பட்டியல் அல்லது array-இல் இருந்து series உருவாக்கும்போது இயல்பாக index ஆகும்), அல்லது date interval போன்ற சிக்கலான அமைப்பைக் கொண்டிருக்கலாம்.
**Series** என்பது மதிப்புகளின் வரிசை, பட்டியலோ numpy array போலவே. முக்கிய வேறுபாடு அது ஒரு **index** உடையதாக இருக்கும், மற்றும் நாம் series இல் செயல்படும்போது (எ.கா., கூட்டம் செய்யும்போது), index கருதப்படும். Index என்பது எளிய முழுமைக் க்கெண் வரிசை நாட்கள் தொகை (Series ஐ பட்டியல் அல்லது array இருந்து உருவாக்கும் போது இயல்பாகவே பயன்படும் index) அல்லது சிக்கலான அமைப்பு, உதாரணமாக தேதிக் கால இடைவேளையாக இருக்கலாம்.
> **குறிப்பு**: Pandas குறித்த அறிமுக குறியீடு இணைக்கப்பட்ட notebook [`notebook.ipynb`](notebook.ipynb) இல் உள்ளது. இங்கே சில உதாரணங்களை மட்டுமே சுருக்கமாகக் கொடுக்கிறோம், மேலும் முழு notebook-ஐப் பார்க்க நீங்கள் வரவேற்கப்படுகிறீர்கள்.
> **குறிப்பு**: ஆவணத்துடன் இருக்கும் குறிப்புகள் உள்ள notebook [`notebook.ipynb`](notebook.ipynb) இல் சில அறிமுக Pandas குறியீடுகள் உள்ளன. இங்குக் சில எடுத்துக்காட்டுகளையே நாங்கள் குறிப்பிட்டுள்ளோம், மேலும் முழு notebook ஐப் பார்க்க வரவேற்கப்படுகிறீர்கள்.
ஒரு உதாரணத்தைப் பரிசீலிக்கவும்: நாங்கள் எங்கள் ice-cream கடையின் விற்பனையைப் பகுப்பாய்வு செய்ய விரும்புகிறோம். ஒரு குறிப்பிட்ட காலத்திற்கு விற்பனைக் கணக்குகளின் (ஒவ்வொரு நாளும் விற்கப்பட்ட பொருட்களின் எண்ணிக்கை) வரிசையை உருவாக்குவோம்:
உதாரணமாக நினைக்கலாம்: நமது ஐஸ் க்ரீம் கடையின் விற்பனையை பகுப்பாய்வு செய்ய விரும்புகிறோம். ஒரு காலகட்டத்திற்கு விற்பனை எண்ணிக்கை வரிசையை (ஒவ்வொரு நாளும் விற்பனை செய்யப்பட்ட பொருட்களின் எண்ணிக்கை) உருவாக்குவோம்:
```python
start_date = "Jan 1, 2020"
@ -67,20 +68,20 @@ items_sold.plot()
```
இப்போது ஒவ்வொரு வாரமும் நாங்கள் நண்பர்களுக்காக ஒரு பார்ட்டி ஏற்பாடு செய்கிறோம், மேலும் ஒரு பார்ட்டிக்காக கூடுதல் 10 ice-cream பாக்ஸ் எடுக்கிறோம். இதை காட்ட மற்றொரு series உருவாக்கலாம்:
இப்போது ஒவ்வொரு வாரமும் நாங்கள் நண்பர்களுக்கான ஒரு பார்ட்டி ஏற்பாடு செய்கிறோம், அதற்காக கூடுதல் 10 ஐஸ் க்ரீம் பாக்கெட்டுகளை எடுத்துக் கொள்கிறோம். இதனை காட்டும் வரிசையை வார வாரம் index கொண்டு உருவாக்கலாம்:
> **குறிப்பு**: எளிய syntax `total_items+additional_items`-ஐப் பயன்படுத்தவில்லை. அதைச் செய்திருந்தால், resulting series-ல் பல `NaN` (*Not a Number*) மதிப்புகளைப் பெற்றிருப்போம். இது `additional_items` series-ல் சில index புள்ளிகளுக்கு missing values உள்ளதால், மேலும் `NaN`-ஐ எதற்கும் சேர்த்தால் `NaN` ஆகிறது. எனவே addition செய்யும்போது `fill_value` parameter-ஐ குறிப்பிட வேண்டும்.
> **குறிப்பு** நாம் நேரடி தொகுப்பு `total_items+additional_items` என்ற திறன் மொழியைப் பயன்படுத்தவில்லை. அது நடந்திருந்தால், முடிவில் வீரியமான `NaN` (*எண் அல்ல*) மதிப்புகளைக் காணத்தக்கதாயிருக்கும். இது எதற்கு என்றால் `additional_items` வரிசையில் சில index இடங்களில் பத்தியான மதிப்புகள் இல்லை என்பதும், `Nan` ஐ எந்த எண்ணியைக்கும் கூட்டும் போது `NaN` பிரதி வரும் என்பதுமான காரணத்தால் ஆகும். ஆகவே கூட்டும் போது `fill_value` என்ற அலகினை குறிப்பிடுவது அவசியம்.
Time series-களுடன், நாம் **resample** செய்யலாம், அதாவது series-ஐ வேறு நேர இடைவெளிகளுடன் மாற்றலாம். உதாரணமாக, மாதாந்திர விற்பனை அளவின் சராசரியை கணக்கிட விரும்பினால், பின்வரும் குறியீட்டை பயன்படுத்தலாம்:
கால தேவைகள் கொண்ட இந்த வரிசைகளை நாம் வேறு வேறு நேர இடைவெளிகளுக்கு **மீண்டும் மாதிரிப் படுத்தலாம்**. உதாரணமாக மாதந்தொறும் சராசரி விற்பனையை கணக்கிட விரும்பினால், கீழே உள்ள குறியீட்டை பயன்படுத்தலாம்:
```python
monthly = total_items.resample("1M").mean()
ax = monthly.plot(kind='bar')
@ -89,23 +90,23 @@ ax = monthly.plot(kind='bar')
### DataFrame
DataFrame என்பது ஒரே index-ஐ கொண்ட பல series-களின் தொகுப்பாகும். பல series-களை ஒன்றாக இணைத்து DataFrame உருவாக்கலாம்:
DataFrame என்பது பொதுவாக ஒரே Index கொண்ட பல Series களின் தொகுப்பாகும். சில Series களை ஒன்றாக சேர்த்து DataFrame உருவாக்கலாம்:
```python
a = pd.Series(range(1,10))
b = pd.Series(["I","like","to","play","games","and","will","not","change"],index=range(0,9))
df = pd.DataFrame([a,b])
```
இது பின்வருமாறு ஒரு கிடைமட்ட அட்டவணையை உருவாக்கும்:
` எழுதுவதன் மூலம் இந்த அட்டவணை அமைப்பைப் பெறலாம். `.T` என்பது DataFrame-ஐ transpose செய்யும் செயல்பாடு, அதாவது வரிசைகள் மற்றும் நெடுவரிசைகளை மாற்றுவது, மேலும் `rename` செயல்பாடு column-களை முந்தைய உதாரணத்துடன் பொருந்த하도록 பெயரிட அனுமதிக்கிறது.
இங்கு `.T` என்பது DataFrame ஐ மாற்றும் செயலில் பயன்படுத்தப்படுகிறது, அதாவது வரிசைகள் மற்றும் நெடுவரிசைகள் மாற்றப்படுகிறது, மேலும் `rename` மூலம் நெடுவரிசைகளை முன்பு எடுத்துக்காட்டிற்கு பொருந்தும் வகையில் பெயரிட முடியும்.
DataFrames-ல் செய்யக்கூடிய சில முக்கிய செயல்பாடுகள் இங்கே:
DataFrames க்கு செய்யக்கூடிய சில முக்கிய செயல்பாடுகள்:
**Column தேர்வு**. தனிப்பட்ட column-களை `df['A']` எழுதுவதன் மூலம் தேர்வு செய்யலாம் - இந்த செயல்பாடு Series-ஐ திருப்புகிறது. `df[['B','A']]` எழுதுவதன் மூலம் column-களின் துணைத் தொகுப்பை மற்றொரு DataFrame-க்கு தேர்வு செய்யலாம் - இது மற்றொரு DataFrame-ஐ திருப்புகிறது.
**நெடுவரிசை தெரிவு**. தனி நெடுவரிசைகளை `df['A']` என்று எழுதி தெரிவு செய்யலாம் - இது Seriesஐ தரும். மேலும் சில நெடுவரிசைகள் தொகுப்பை `df[['B','A']]` என்ற முறையில் தேர்வு செய்யலாம் - இது மற்றொரு DataFrame ஐ தரும்.
**குறிப்பிட்ட வரிசைகளைத் தேர்வு செய்வது**. உதாரணமாக, column `A` 5-ஐ விட அதிகமாக உள்ள வரிசைகளை மட்டும் விட்டு விட `df[df['A']>5]` எழுதலாம்.
**தேர்வு செய்வது** தகுந்த வரிப்பட்டியலை மட்டும் இடம் பெற. உதாரணமாக, நெடுவரிசை `A` ஐ 5 ரூபாய்க்கும் மேற்பட்ட வரிகளை மட்டும் புறतடுக்க `df[df['A']>5]` என எழுத்தலாம்.
> **குறிப்பு**: Filtering செயல்படும் விதம் பின்வருமாறு. `df['A']<5` என்ற வெளிப்பாடு boolean series-ஐ திருப்புகிறது, இது அசல் series `df['A']`-இல் ஒவ்வொரு உருப்படிக்குமான வெளிப்பாடு `True` அல்லது `False` என்பதை குறிக்கிறது. Boolean series index ஆக பயன்படுத்தப்படும் போது, DataFrame-ல் உள்ள வரிசைகளின் துணைத் தொகுப்பை திருப்புகிறது. எனவே, பொதுவான Python boolean வெளிப்பாட்டைப் பயன்படுத்த முடியாது, உதாரணமாக, `df[df['A']>5 and df['A']<7]` எழுதுவது தவறாக இருக்கும். அதற்கு பதிலாக, boolean series-ல் சிறப்பு `&` செயல்பாட்டைப் பயன்படுத்தி `df[(df['A']>5) & (df['A']<7)]`(*இங்கே அடுக்குகள் முக்கியம்*) எழுத வேண்டும்.
> **குறிப்பு**: தேர்வு செய்யும் முறை பின்வருமாறு. வெளிப்பாடு `df['A']<5` ஒரு பூலிய வரிசை தருகிறது, இது அசலான `df['A']` என்பதன் ஒவ்வொரு உறுப்பிற்கும் அது `True` ஆகுமா அல்லது `False` ஆகுமா எனக் காட்டுகிறது. பூலிய வரிசை ஒரு Index ஆகப் பயன்படுத்தப்படும்போது, அது DataFrame இல் சார்ந்த வரிசைகள் ஒன்றுசேர்கிறது. ஆகவே சீரற்ற பைத்தான் பூலிய வெளிப்பாடு, உதாரணமாக `df[df['A']>5 and df['A']<7]` தவறானது. பதிலாக, பூலிய வரிசையில் சிறப்பு `&` செயல்பாட்டைப் பயன்படுத்தி,`df[(df['A']>5) & (df['A']<7)]`என்று எழுதியல் (*வரிசைகள் முக்கியம்*).
**புதிய கணக்கிடக்கூடிய column-களை உருவாக்குவது**. DataFrame-க்கு புதிய கணக்கிடக்கூடிய column-களை எளிதாக உருவாக்கலாம்:
**புதிய கணக்கிடக்கூடிய நெடுவரிசைகளை உருவாக்குதல்**. நமது DataFrame க்கு எளிதாகக் கணக்கிடக்கூடிய புதிதான நெடுவரிசைகள் உருவாக்கலாம் இந்த மாதிரி விளக்கமான வெளிப்பாடுகளைக் கொண்டு:
```python
df['DivA'] = df['A']-df['A'].mean()
```
இந்த உதாரணம் A-இன் mean மதிப்பிலிருந்து A-இன் வேறுபாட்டை கணக்கிடுகிறது. இங்கே உண்மையில் என்ன நடக்கிறது என்றால், நாம் ஒரு series-ஐ கணக்கிடுகிறோம், பின்னர் இந்த series-ஐ இடது பக்கம் ஒதுக்கி, மற்றொரு column-ஐ உருவாக்குகிறோம். எனவே, series-க்கு பொருந்தாத எந்த செயல்பாடுகளையும் பயன்படுத்த முடியாது, உதாரணமாக, கீழே உள்ள குறியீடு தவறாகும்:
இந்த எடுத்துக்காட்டு A இன் சராசரி மதிப்பிலிருந்து வேறுபாட்டை கணக்கிடுகிறது. இங்கு நாம் ஒரு Series ஐ கம்பியுடன் உருவாக்கி அதை இடதுபுறம் நெடுவரிசையாக ஒதுக்கீடு செய்கிறோம். எனவே Series க்கு பொருந்தாத எந்த செயல்களையும் பயன்படுத்த முடியாது, உதாரணமாக கீழ்க்காணும் குறியீடு தவறானது:
```python
# Wrong code -> df['ADescr'] = "Low" if df['A'] <5else"Hi"
df['LenB'] = len(df['B']) # <-Wrongresult
# தவறான குறியீடு -> df['ADescr'] = "குறைவு" என்றால் df['A'] <5இல்லைஎன்றால்"உயர்"
df['LenB'] = len(df['B']) # <-தவறானமுடிவு
```
கீழே உள்ள உதாரணம், ச syntactically சரியானதாக இருந்தாலும், தவறான முடிவைத் தருகிறது, ஏனெனில் இது series `B`-இன் நீளத்தை column-ல் உள்ள அனைத்து மதிப்புகளுக்கும் ஒதுக்குகிறது, ஆனால் நாம் எதிர்பார்த்த individual elements-இன் நீளத்தை அல்ல.
இறுதிப் படைப்பு, இலக்கண ரீதியாக சரியாக இருந்தாலும், நமது நோக்கமிற்கு மாறாக, ஒவ்வொரு உறுப்பின் நீளத்தை அல்ல, Series B யின் மொத்த நீளத்தை நெடுவரிசை மெதுவாக ஒதுக்கிகிறது, எனவே தவறு.
இந்த மாதிரியான சிக்கலான வெளிப்பாடுகளை கணக்கிட வேண்டும் என்றால், `apply` செயல்பாட்டைப் பயன்படுத்தலாம். கடைசி உதாரணத்தை பின்வருமாறு எழுதலாம்:
சிக்கலான வெளிப்பாடுகளை கணக்கிட விரும்பினால், `apply` செயலியை பயன்படுத்தலாம். கடைசி எடுத்துக்காட்டை பின்வருமாறு எழுதலாம்:
```python
df['LenB'] = df['B'].apply(lambda x : len(x))
# or
# அல்லது
df['LenB'] = df['B'].apply(len)
```
மேலே உள்ள செயல்பாடுகளுக்குப் பிறகு, பின்வரும் DataFrame-ஐப் பெறுவோம்:
மேலே கூறிய செயல்பாட்டுக்குப் பிறகு, நமக்கு கீழ்காணும் DataFrame கிடைக்கும்:
**எண்களைக் கொண்டு வரிசைகளைத் தேர்வு செய்வது** `iloc` construct-ஐப் பயன்படுத்தி செய்யலாம். உதாரணமாக, DataFrame-ல் முதல் 5 வரிசைகளைத் தேர்வு செய்ய:
**எண்களை அடிப்படையாகக் கொண்டு வரிசைகளைத் தேர்வு செய்தல்** `iloc` கட்டமைப்பைப் பயன்படுத்தி செய்யலாம். உதாரணமாக, DataFrame இல் முதல் 5 வரிசைகளை தேர்வுசெய்ய:
```python
df.iloc[:5]
```
**Grouping** Excel-இல் உள்ள *pivot tables* போன்ற முடிவுகளைப் பெற அடிக்கடி பயன்படுத்தப்படுகிறது. Column `A`-இன் mean மதிப்பை ஒவ்வொரு `LenB` எண்ணிக்கைக்கும் கணக்கிட விரும்பினால், `LenB` மூலம் DataFrame-ஐ குழுவாகக் கொண்டு, `mean`-ஐ அழைக்கலாம்:
**குழு கட்டமைப்புகள்** Excel இல் உள்ள *pivot tables* போன்ற முடிவுகளை பெற பயன்படும். உதாரணமாக நெடுவரிசை `LenB` இன் ஒவ்வொரு மதிப்புக்கும் நெடுவரிசை `A` இன் சராசரி மதிப்பை கணக்கிட விரும்பினால், `LenB` உடன் DataFrame ஐ குழுவாக்கி, `mean` செயலியைப் பயன்படுத்தலாம்:
```python
df.groupby(by='LenB')[['A','DivA']].mean()
```
Mean மற்றும் குழுவில் உள்ள உருப்படிகளின் எண்ணிக்கையை கணக்கிட வேண்டும் என்றால், மேலும் சிக்கலான `aggregate` செயல்பாட்டைப் பயன்படுத்தலாம்:
ஒரே குழுவில் சராசரி மற்றும் உறுப்புகள் எண்ணிக்கை இரண்டும் தேவைப்படின், சிக்கலான `aggregate` செயலியை பயன்படுத்தலாம்:
நாம் Python பொருட்களிலிருந்து Series மற்றும் DataFrames உருவாக்க எவ்வளவு எளிது என்பதை பார்த்தோம். ஆனால், தரவுகள் பொதுவாக ஒரு உரை கோப்பு அல்லது Excel அட்டவணை வடிவத்தில் வரும். அதிர்ஷ்டவசமாக, Pandas தரவுகளை டிஸ்கில் இருந்து ஏற்ற எளிய வழியை வழங்குகிறது. உதாரணமாக, CSV கோப்பை படிக்க இது போன்ற எளிதானது:
இதனால் கீழ்காணும் அட்டவணை கிடைக்கும்:
| LenB | எண்ணிக்கை | சராசரி |
| ---- | ---------- | ----------- |
| 1 | 1 | 1.000000 |
| 2 | 1 | 3.000000 |
| 3 | 2 | 5.000000 |
| 4 | 3 | 6.333333 |
| 6 | 2 | 6.000000 |
### தரவைப் பெறுதல்
Python பொருட்களிலிருந்து Series மற்றும் DataFrames உருவாக்க எளிமையானது என்பதை நாமாய் பார்த்துவிட்டோம். எனினும், தரவு பொதுவாக ஒரு உரை கோப்பு அல்லது Excel அட்டவணை வடிவத்தில் வரும். அதற்கெதிராக, Pandas எங்களுக்கு தரவுகளை வட்டு இயக்கியில் இருந்து எப்படிப் போர்த்துவது என்பது ஒரு எளிய வழியை வழங்குகிறது. உதாரணமாக, CSV கோப்பை வாசிப்பது இவ்வளவுதான் எளிமை:
```python
df = pd.read_csv('file.csv')
```
"சவால்" பிரிவில், வெளிப்புற வலைத்தளங்களில் இருந்து தரவுகளை பெறுவது உட்பட, மேலும் பல தரவுகளை ஏற்ற உதாரணங்களை காண்போம்.
"சவால்" பிரிவில் வெளிப்புற வலைத்தளங்களிலிருந்து தரவை பெறுதல் உட்பட, தரவை போர்த்தும் பல எடுத்துக்காட்டுகளை நாம் பார்க்கப்போகிறோம்
### அச்சிடுதல் மற்றும் வரைபடம்
### அச்சிடல் மற்றும் வரைபடம் வரைவல்
ஒரு தரவியல் விஞ்ஞானி அடிக்கடி தரவுகளை ஆராய வேண்டும், எனவே அதை காட்சிப்படுத்தும் திறன் முக்கியமானது. DataFrame பெரியதாக இருந்தால், பல நேரங்களில் நாம் சரியாக செய்கிறோம் என்பதை உறுதிப்படுத்த முதல் சில வரிகளை அச்சிட விரும்புகிறோம். இதை `df.head()` அழைப்பதன் மூலம் செய்யலாம். நீங்கள் Jupyter Notebook-ல் இதை இயக்கினால், DataFrame-ஐ அழகான அட்டவணை வடிவத்தில் அச்சிடும்.
ஒரு தரவியல் விஞ்ஞானி பெரும்பாலும் தரவை ஆய்வு செய்ய வேண்டும், அதனால் அதை பார்வையிட முடியும் என்பது முக்கியம். DataFrame பெரியதாயினும், பல நேரங்களில் நாம் அனைத்தும் சரியாக நடக்கின்றனவா என்று உறுதி செய்யும் நோக்கில் சில முதல் வரிசைகளை அச்சிட விரும்புகிறோம். இது `df.head()` என்பதை அழுத்துவதன் மூலம் செய்யலாம். நீங்கள் Jupyter Notebook-இல் இதை இயக்கினால், DataFrame ஒரு அழுத்தமான அட்டவணை வடிவில் அச்சிடப்படும்.
நாம் சில களங்களை காட்சிப்படுத்த `plot` செயல்பாட்டின் பயன்பாட்டை பார்த்தோம். `plot` பல பணிகளுக்கு மிகவும் பயனுள்ளதாக உள்ளது, மேலும் `kind=` பராமரிப்பின் மூலம் பல்வேறு வகை வரைபடங்களை ஆதரிக்கிறது. ஆனால், நீங்கள் எப்போதும் மூல `matplotlib` நூலகத்தைப் பயன்படுத்தி மேலும் சிக்கலானதை வரைபடம் செய்யலாம். தரவுக் காட்சிப்படுத்தல் பற்றிய விரிவான பாடங்களை தனித்தனியாக கற்கைநெறிகளில் கையாளுவோம்.
சில நெடுவரிசைகளை காண்பிக்க, `plot` அம்சத்தின் பயன்பாட்டையும் நாம்வீட்டுள்ளோம். `plot` பல பணிகளுக்கு மிக பயனுள்ளதாக இருக்கிறது, மற்றும் `kind=` ஆகும் அளவுருவை மையமாக கொண்டு பல்வேறு வரைபட வகைகளை ஆதரிக்கிறது; நீங்கள் எப்போதும் `matplotlib` நூலகத்தை நேரடியாக பயன்படுத்தி முறைசாரா கடினமான வரைபடங்களை வரைய முடியும். தரவு காட்சி பற்றி தனி பாடங்களில் விரிவாகப் பேசுவோம்.
இந்த சுருக்கம் Pandas இன் முக்கியமான கருத்துக்களை உள்ளடக்கியது, ஆனால் இந்த நூலகம் மிகவும் வளமானது, மேலும் இதன் மூலம் நீங்கள் செய்யக்கூடியவற்றுக்கு எல்லையில்லை! இப்போது இந்த அறிவை குறிப்பிட்ட பிரச்சினையைத் தீர்க்க பயன்படுத்துவோம்.
இந்த பார்வை Pandas இன் மிக முக்கியமான கருத்துக்களை உள்ளடக்கியது, ஆனால், நூலகம் மிகச் செற்றது, நீங்கள் இதனுடன் செய்யக்கூடியவை எல்லைக்கு வரம்பில்லை! இப்போது குறிப்பிட்ட பிரச்சனையை தீர்க்க இதை பயன்படுத்துவோம்.
## 🚀 சவால் 1: COVID பரவலைப் பகுப்பாய்வு
## 🚀 சவால் 1: COVID பரவலை பகுப்பாய்வு செய்தல்
முதல் பிரச்சினை COVID-19 தொற்றுநோயின் பரவலை மாதிரியாக்கல் ஆகும். இதைச் செய்ய, [Center for Systems Science and Engineering](https://systems.jhu.edu/) (CSSE) மற்றும் [Johns Hopkins University](https://jhu.edu/) வழங்கிய, பல நாடுகளில் பாதிக்கப்பட்டவர்களின் எண்ணிக்கையைப் பற்றிய தரவுகளைப் பயன்படுத்துவோம். இந்த தரவுத்தொகுப்பு [இந்த GitHub Repository](https://github.com/CSSEGISandData/COVID-19) இல் கிடைக்கிறது.
முதன்மை பிரச்சினை நாம் கவனம் செலுத்தப்போகும் COVID-19 தொற்று பரவல் மாதிரியாகும். அதற்காக, வெவ்வேறு நாடுகளிலுள்ள பாதிக்கப்பட்ட நபர்களின் எண்ணிக்கையைப் பற்றிய தரவுகளை, [Center for Systems Science and Engineering](https://systems.jhu.edu/) (CSSE), [Johns Hopkins University](https://jhu.edu/) வழங்கும். தரவுத்தொகுப்பு [இந்த GitHub Repository](https://github.com/CSSEGISandData/COVID-19) யில் கிடைக்கிறது.
தரவுகளை எப்படி கையாள வேண்டும் என்பதை விளக்க, [`notebook-covidspread.ipynb`](notebook-covidspread.ipynb) ஐ திறந்து மேலிருந்து கீழ்வரை படிக்குமாறு உங்களை அழைக்கிறோம். நீங்கள் செல்களை இயக்கவும், இறுதியில் நாம் விட்டுச் சென்ற சில சவால்களைச் செய்யவும் முடியும்.
தரவு எப்படி கையாள்வது என்பதை göstறுவதை நோக்கி, [`notebook-covidspread.ipynb`](notebook-covidspread.ipynb)-ஐ திறந்து பின்புறம் வாசிக்க அழைக்கிறோம். நீங்கள் செல்லமைப்புகளை இயக்கு கூடும், நான் முடிவில் நீங்கள் செய்ய ஊடுருவியும் சவால்களை விடுத்துள்ளோம்.
> Jupyter Notebook-ல் குறியீட்டை இயக்குவது எப்படி என்று தெரியவில்லை என்றால், [இந்த கட்டுரை](https://soshnikov.com/education/how-to-execute-notebooks-from-github/) பார்க்கவும்.
> Jupyter Notebook-ல் குறியீட்டை இயக்க எப்படி என தெரியவில்லை என்றால், [இந்தக் கட்டுரையை](https://soshnikov.com/education/how-to-execute-notebooks-from-github/) பாருங்கள்.
## அமைப்பற்ற தரவுகளுடன் வேலை செய்வது
## கட்டமைக்கப்படாத தரவுடன் வேலை செய்யல்
தரவுகள் அடிக்கடி அட்டவணை வடிவத்தில் வரும், ஆனால் சில சந்தர்ப்பங்களில் குறைவான அமைப்புடைய தரவுகளை, உதாரணமாக உரை அல்லது படங்களை கையாள வேண்டும். இந்தச் சந்தர்ப்பத்தில், மேலே பார்த்த தரவுகளை செயலாக்க தொழில்நுட்பங்களைப் பயன்படுத்த, **அமைப்புடைய** தரவுகளை எப்படியாவது **எடுக்க** வேண்டும். சில உதாரணங்கள் இவை:
தரவு பெரும்பாலும் அட்டவணை வடிவில் வரும் என்றாலும், சில நாட்களில் நாம் கட்டமைக்கப்படாத தரவுகளை உள்ளடக்க வேண்டும், உதாரணமாக உரை அல்லது படங்கள். இந்நிலையில், மேலே பார்ந்த தரவு செயலாக்க தொழில்நுட்பங்களைப் பயன்படுத்த, நாம் எப்படியாவது கட்டமைக்கப்பட்ட தரவை **திரட்ட** வேண்டியுள்ளது. சில எடுத்துக்காட்டுகள்:
* உரையிலிருந்து முக்கிய வார்த்தைகளை எடுத்து, அவை எவ்வளவு முறை தோன்றுகின்றன என்பதைப் பார்க்க
* படத்தில் உள்ள பொருட்களைப் பற்றிய தகவலை எடுக்க நரம்பியல் வலைகளைப் பயன்படுத்துதல்
* வீடியோ கேமரா பீடில் உள்ள மக்களின் உணர்வுகளைப் பற்றிய தகவலைப் பெறுதல்
* உரையிலிருந்து முக்கியச் சொற்களை திரட்டி அவை எத்தனை முறை தோன்றுகின்றன என்பதை காண்பது
* படத்தில் உள்ள பொருட்களை பற்றிய தகவல்களை neural networks பயன்படுத்தி எடுக்குதல்
* வீடியோ கேமரா கேட்பில் உள்ள மக்களின் உணர்வுகளைப் பெறுதல்
## 🚀 சவால் 2: COVID ஆய்வுக் கட்டுரைகளைப் பகுப்பாய்வு
## 🚀 சவால் 2: COVID ஆய்வுக் கட்டுரைகளை பகுப்பாய்வு செய்தல்
இந்த சவாலில், COVID தொற்றுநோயின் தலைப்புடன் தொடர்ந்து, இந்த விஷயத்தில் அறிவியல் ஆய்வுக் கட்டுரைகளை செயலாக்க கவனம் செலுத்துவோம். [CORD-19 Dataset](https://www.kaggle.com/allen-institute-for-ai/CORD-19-research-challenge) இல் 7000 க்கும் மேற்பட்ட (எழுதும் நேரத்தில்) COVID பற்றிய கட்டுரைகள், மெட்டாடேட்டா மற்றும் சுருக்கங்களுடன் (அவற்றில் பாதி முழு உரையுடன்) கிடைக்கின்றன.
இந்த சவாலை COVID தொற்றுநிலைபேறின் தலைப்பில் தொடர்கிறோம், மற்றும் இந்தப்பொருளில் உள்ள அறிவியல் கட்டுரைகளை செயலாக்க சுற்றிலும் கவனம் செலுத்துகிறோம். [CORD-19 Dataset](https://www.kaggle.com/allen-institute-for-ai/CORD-19-research-challenge) COVID பற்றிய 7000-க்கும் மேற்பட்ட (எழுதும் நேரத்தில்) ஆராய்ச்சி கட்டுரைகள், மேட்டாடேட்டா மற்றும் சுருக்கங்களுடன் (அரை கட்டுரைகளுக்கு முழு உரையும் வழங்கப்பட்டுள்ளது) கிடைக்கிறது.
இந்த தரவுத்தொகுப்பை [Text Analytics for Health](https://docs.microsoft.com/azure/cognitive-services/text-analytics/how-tos/text-analytics-for-health/?WT.mc_id=academic-77958-bethanycheum) அறிவாற்றல் சேவையைப் பயன்படுத்தி பகுப்பாய்வு செய்வதற்கான முழு உதாரணம் [இந்த வலைப்பதிவில்](https://soshnikov.com/science/analyzing-medical-papers-with-azure-and-text-analytics-for-health/) விவரிக்கப்பட்டுள்ளது. இந்த பகுப்பாய்வின் எளிய பதிப்பை நாம் விவாதிக்கிறோம்.
[Text Analytics for Health](https://docs.microsoft.com/azure/cognitive-services/text-analytics/how-tos/text-analytics-for-health/?WT.mc_id=academic-77958-bethanycheum) அறிவுக்கோள் சேவையைப் பயன்படுத்தி இந்த தரவுத்தொகுப்பை பகுப்பாய்வு செய்த ஒரு முழு எடுத்துக்காட்டு [இந்த வலைப்பதிவில்](https://soshnikov.com/science/analyzing-medical-papers-with-azure-and-text-analytics-for-health/) விளக்கப்பட்டுள்ளது. எங்களால் சரளப்படுத்தப்பட்ட பகுப்பாய்வையும் விவாதிப்போம்.
> **NOTE**: இந்த தொகுப்பின் ஒரு நகலை இந்த repository இல் வழங்கவில்லை. முதலில் [`metadata.csv`](https://www.kaggle.com/allen-institute-for-ai/CORD-19-research-challenge?select=metadata.csv) கோப்பை [இந்த Kaggle தொகுப்பில்](https://www.kaggle.com/allen-institute-for-ai/CORD-19-research-challenge) பதிவிறக்க வேண்டும். Kaggle-ல் பதிவு தேவைப்படலாம். பதிவு இல்லாமல் [இங்கே](https://ai2-semanticscholar-cord-19.s3-us-west-2.amazonaws.com/historical_releases.html) பதிவிறக்கலாம், ஆனால் இது மெட்டாடேட்டா கோப்புடன் முழு உரைகளை உள்ளடக்கியதாக இருக்கும்.
> **குறிப்பு**: இந்த தொகுப்பின் ஒரு பிரதியை இந்த தொகுப்பில் வழங்கவில்லை. முதலில் [இந்த Kaggle தரவுத்தொகுப்பில்](https://www.kaggle.com/allen-institute-for-ai/CORD-19-research-challenge?select=metadata.csv) உள்ள [`metadata.csv`](https://www.kaggle.com/allen-institute-for-ai/CORD-19-research-challenge?select=metadata.csv) கோப்பை பதிவிறக்கம் செய்ய வேண்டும். Kaggle இல் பதிவு அவசியமாக இருக்கலாம். பதிவு இல்லாமல் பதிவிறக்கம் செய்ய [இங்கே](https://ai2-semanticscholar-cord-19.s3-us-west-2.amazonaws.com/historical_releases.html) இருந்தும் பதிவிறக்க முடியும், ஆனால் அது முழு உரைகளும் உள்ளடங்கும், metadata கோப்புக்கு கூடுதலாக.
[`notebook-papers.ipynb`](notebook-papers.ipynb) ஐ திறந்து மேலிருந்து கீழ்வரை படிக்கவும். நீங்கள் செல்களை இயக்கவும், இறுதியில் நாம் விட்டுச் சென்ற சில சவால்களைச் செய்யவும் முடியும்.
[`notebook-papers.ipynb`](notebook-papers.ipynb)-ஐ திறந்து தொடர்ந்து வாசிக்கவும். செல்லமைப்புகளை இயக்கு கூடும், நீங்கள் முடிவில் செய்யுமாறு விட்டுச் சென்ற சவால்களை செய்யவும்.
## பட தரவுகளை செயலாக்குதல்
## படத் தரவை செயலாக்குதல்
சமீபத்தில், படங்களைப் புரிந்துகொள்ள சக்திவாய்ந்த AI மாதிரிகள் உருவாக்கப்பட்டுள்ளன. முன்பே பயிற்சி பெற்ற நரம்பியல் வலைகளை அல்லது மேக சேவைகளைப் பயன்படுத்தி பல பணிகளை தீர்க்க முடியும். சில உதாரணங்கள்:
சமீபத்தில், படங்களை புரிந்துகொள்ள நமக்கு அனுமதிக்கும் மிகவும் வலுவான AI மாதிரிகள் உருவாக்கப்பட்டுள்ளன. முன்கூட்டியே பயிற்று பெற்ற neural networkகள் அல்லது மேகம் சேவைகள் மூலம் பல பணிகளைத் தீர்க்க முடியும். சில எடுத்துக்காட்டுகள்:
* **பட வகைப்படுத்தல்**, இது படத்தை முன்பே வரையறுக்கப்பட்ட வகைகளில் ஒன்றாக வகைப்படுத்த உதவுகிறது. [Custom Vision](https://azure.microsoft.com/services/cognitive-services/custom-vision-service/?WT.mc_id=academic-77958-bethanycheum) போன்ற சேவைகளைப் பயன்படுத்தி உங்கள் சொந்த பட வகைப்படுத்திகளை எளிதாக பயிற்சி செய்யலாம்.
* **பொருள் கண்டறிதல்** படத்தில் உள்ள பல்வேறு பொருட்களை கண்டறிய. [Computer Vision](https://azure.microsoft.com/services/cognitive-services/computer-vision/?WT.mc_id=academic-77958-bethanycheum) போன்ற சேவைகள் பொதுவான பொருட்களை கண்டறிய உதவுகிறது, மேலும் [Custom Vision](https://azure.microsoft.com/services/cognitive-services/custom-vision-service/?WT.mc_id=academic-77958-bethanycheum) மாதிரியை குறிப்பிட்ட பொருட்களை கண்டறிய பயிற்சி செய்யலாம்.
* **முகம் கண்டறிதல்**, வயது, பாலினம் மற்றும் உணர்வு கண்டறிதல் உட்பட. இது [Face API](https://azure.microsoft.com/services/cognitive-services/face/?WT.mc_id=academic-77958-bethanycheum) மூலம் செய்யலாம்.
* **பட வகைப்படுத்தல்**, இது ஓர் உருவாக்கப்பட்ட வகைபாடுகளில் படங்களை வகைப்படுத்த உதவும். நீங்கள் [Custom Vision](https://azure.microsoft.com/services/cognitive-services/custom-vision-service/?WT.mc_id=academic-77958-bethanycheum) போன்ற சேவைகள் பயன்படுத்தி உங்கள் சொந்த பட வகைப்பாளர்களை எளிதில் பயிற்றுவிக்கலாம்
* **பொருள் கண்டறிதல்** படத்தில் பல பொருட்களை கண்டறிய. [computer vision](https://azure.microsoft.com/services/cognitive-services/computer-vision/?WT.mc_id=academic-77958-bethanycheum) போன்ற சேவைகள் சில பொதுவான பொருட்களை கண்டறிய முடியும், மற்றும் [Custom Vision](https://azure.microsoft.com/services/cognitive-services/custom-vision-service/?WT.mc_id=academic-77958-bethanycheum) மூலம் உங்கள் தேவைக்கு ஏற்ப சில சிறப்பு பொருட்களை கண்டறிய பயிற்றுவிக்கலாம்.
* **முகம் கண்டறிதல்**, வயது, பாலினம் மற்றும் உணர்வு கண்டறிதலை உட்பட. இது [Face API](https://azure.microsoft.com/services/cognitive-services/face/?WT.mc_id=academic-77958-bethanycheum) மூலம் செய்யக்கூடும்.
இந்த மேக சேவைகள் அனைத்தும் [Python SDKs](https://docs.microsoft.com/samples/azure-samples/cognitive-services-python-sdk-samples/cognitive-services-python-sdk-samples/?WT.mc_id=academic-77958-bethanycheum) மூலம் அழைக்கப்படலாம், எனவே உங்கள் தரவுகளை ஆராயும் பணியில் எளிதாக இணைக்கலாம்.
இந்த மேகம் சேவைகள் அனைத்தும் [Python SDKகளை](https://docs.microsoft.com/samples/azure-samples/cognitive-services-python-sdk-samples/cognitive-services-python-sdk-samples/?WT.mc_id=academic-77958-bethanycheum) பயன்படுத்தி அழைக்கப்படலாம் மற்றும் எனவே உங்கள் தரவு ஆய்வு பணிசூழலில் எளிதில் இணைக்கப்படலாம்.
பட தரவுத் தரவுகளை ஆராய சில உதாரணங்கள்:
* [How to Learn Data Science without Coding](https://soshnikov.com/azure/how-to-learn-data-science-without-coding/) வலைப்பதிவில், Instagram புகைப்படங்களை ஆராய்ந்து, ஒரு புகைப்படத்திற்கு மக்கள் அதிக லைக்குகளை வழங்க என்ன காரணமாகிறது என்பதைப் புரிந்துகொள்கிறோம். முதலில் [Computer Vision](https://azure.microsoft.com/services/cognitive-services/computer-vision/?WT.mc_id=academic-77958-bethanycheum) மூலம் புகைப்படங்களில் இருந்து அதிக தகவல்களை எடுத்து, பின்னர் [Azure Machine Learning AutoML](https://docs.microsoft.com/azure/machine-learning/concept-automated-ml/?WT.mc_id=academic-77958-bethanycheum) ஐப் பயன்படுத்தி விளக்கமான மாதிரியை உருவாக்குகிறோம்.
* [Facial Studies Workshop](https://github.com/CloudAdvocacy/FaceStudies) இல், [Face API](https://azure.microsoft.com/services/cognitive-services/face/?WT.mc_id=academic-77958-bethanycheum) ஐப் பயன்படுத்தி நிகழ்வுகளில் உள்ள மக்களின் புகைப்படங்களில் உணர்வுகளை எடுத்து, மக்களை மகிழ்ச்சியாக்க என்ன காரணமாகிறது என்பதைப் புரிந்துகொள்கிறோம்.
படத் தரவுகளிலிருந்து தரவு ஆய்வு செய்த சில எடுத்துக்காட்டு கீழே இவை:
* வலைப்பதிவுத் கட்டுரை [எப்படி குறியீடு இல்லாமல் தரவியலைக் கற்றுக்கொள்வது](https://soshnikov.com/azure/how-to-learn-data-science-without-coding/) இல், Instagram புகைப்படங்களை ஆய்வு செய்து, மக்கள் ஏன் ஒரு புகைப்படம் மீது அதிகமான விருப்பங்களை அளிக்கிறார்கள் என்பதை புரிந்துகொள்கிறோம். முதலில் [computer vision](https://azure.microsoft.com/services/cognitive-services/computer-vision/?WT.mc_id=academic-77958-bethanycheum) பயன்படுத்தி படங்களிலிருந்து சாத்தியமான அளவு தகவலை திரட்டி, பின்னர் [Azure Machine Learning AutoML](https://docs.microsoft.com/azure/machine-learning/concept-automated-ml/?WT.mc_id=academic-77958-bethanycheum) கொண்டு விளக்கக்கூடிய மாதிரியை கட்டியமைக்கிறோம்.
* [Facial Studies Workshop](https://github.com/CloudAdvocacy/FaceStudies) இல் [Face API](https://azure.microsoft.com/services/cognitive-services/face/?WT.mc_id=academic-77958-bethanycheum) பயன்படுத்தி நிகழ்வுகளின் புகைப்படங்களில் உள்ள மக்களின் உணர்வுகளை சேகரித்து, மக்கள் எதனால் மகிழ்ச்சியடைகிறார்கள் என்பதை புரிந்துகொள்ள முயல்கிறோம்.
## முடிவு
நீங்கள் ஏற்கனவே அமைப்புடைய அல்லது அமைப்பற்ற தரவுகளை வைத்திருந்தாலும், Python-ஐப் பயன்படுத்தி தரவுகளை செயலாக்க மற்றும் புரிந்துகொள்ள தொடர்பான அனைத்து படிகளையும் செய்யலாம். இது தரவுகளை செயலாக்க மிகவும் நெகிழ்வான வழியாகும், மேலும் அதனால் பெரும்பாலான தரவியல் விஞ்ஞானிகள் Python-ஐ தங்கள் முதன்மை கருவியாகப் பயன்படுத்துகிறார்கள். உங்கள் தரவியல் பயணத்தில் தீவிரமாக இருக்க விரும்பினால் Python-ஐ ஆழமாக கற்றல் நல்ல யோசனை.
கட்டமைக்கப்பட்ட அல்லது கட்டமைக்கப்படாத தரவு உங்களிடம் இருந்தாலும்கூட, Python ஐப் பயன்படுத்தி தரவு செயலாக்கம் மற்றும் புரிதலில் உள்ள அனைத்து படிகளையும் செய்ய முடியும். இது மிகவும் சுதந்திரமான தரவு செயலாக்க வழி ஆகும், அதுதான் பெரும்பாலான தரவியலை அறிவாளிகள் Python-ஐ அவரது முதன்மை கருவியாக பயன்படுத்துவதன் காரணமாகும். உங்கள் தரவியல் பயணத்தில் நீங்கள் கடுமையாக இருப்பின் Python-ஐ ஆழமாக கற்றுக்கொள்வது நல்ல எண்ணமாக இருக்கும்!
## [பாடத்திற்குப் பிந்தைய வினாடி வினா](https://ff-quizzes.netlify.app/en/ds/quiz/13)
## [பாடநிறுத்தம் பிறகு விடைத் தேர்வு](https://ff-quizzes.netlify.app/en/ds/quiz/13)
## மதிப்பீடு மற்றும் சுயபயிற்சி
## விமர்சனம் & சுயபடிப்பு
**புத்தகங்கள்**
* [Wes McKinney. Python for Data Analysis: Data Wrangling with Pandas, NumPy, and IPython](https://www.amazon.com/gp/product/1491957662)
**ஆன்லைன் வளங்கள்**
* அதிகாரப்பூர்வ [10 minutes to Pandas](https://pandas.pydata.org/pandas-docs/stable/user_guide/10min.html) டுடோரியல்
* [Pandas Visualization பற்றிய ஆவணங்கள்](https://pandas.pydata.org/pandas-docs/stable/user_guide/visualization.html)
* அதிகாரபூர்வ [10 நிமிடங்களில் Pandas கற்றல்](https://pandas.pydata.org/pandas-docs/stable/user_guide/10min.html) பயிற்சி
* [Learn Python in a Fun Way with Turtle Graphics and Fractals](https://github.com/shwars/pycourse)
* [Take your First Steps with Python](https://docs.microsoft.com/learn/paths/python-first-steps/?WT.mc_id=academic-77958-bethanycheum) Microsoft Learn-ல் [Learning Path](http://learn.microsoft.com/?WT.mc_id=academic-77958-bethanycheum)
* [Turtle Graphics மற்றும் Fractals கொண்ட ஒரு பொழுதுபோக்கு முறையில் Python கற்றல்](https://github.com/shwars/pycourse)
* [Python முதலில் படித் தொடக்கம்](https://docs.microsoft.com/learn/paths/python-first-steps/?WT.mc_id=academic-77958-bethanycheum) [Microsoft Learn](http://learn.microsoft.com/?WT.mc_id=academic-77958-bethanycheum) இல் கற்றல் பாதை
## பணிக்கட்டளை
## பணிவகுப்பு
[மேலே உள்ள சவால்களுக்கு மேலும் விரிவான தரவுப் படிப்பைச் செய்யவும்](assignment.md)
[மேலே உள்ள சவால்களுக்கு மேலும் விரிவான தரவு ஆய்வு செய்யவும்](assignment.md)
## கிரெடிட்ஸ்
## கடவுச்சொற்கள்
இந்த பாடம் [Dmitry Soshnikov](http://soshnikov.com) அவர்களால் ♥️ உடன் எழுதப்பட்டுள்ளது.
இந்த பாடத்தை ♥️ உடன் [Dmitry Soshnikov](http://soshnikov.com) எழுதியுள்ளார்
---
**குறிப்பு**:
இந்த ஆவணம் [Co-op Translator](https://github.com/Azure/co-op-translator) என்ற AI மொழிபெயர்ப்பு சேவையை பயன்படுத்தி மொழிபெயர்க்கப்பட்டுள்ளது. எங்கள் நோக்கம் துல்லியமாக இருக்க வேண்டும் என்பதுதான், ஆனால் தானியங்கி மொழிபெயர்ப்புகளில் பிழைகள் அல்லது துல்லியமின்மைகள் இருக்கக்கூடும் என்பதை தயவுசெய்து கவனத்தில் கொள்ளவும். அதன் தாய்மொழியில் உள்ள மூல ஆவணம் அதிகாரப்பூர்வ ஆதாரமாக கருதப்பட வேண்டும். முக்கியமான தகவல்களுக்கு, தொழில்முறை மனித மொழிபெயர்ப்பு பரிந்துரைக்கப்படுகிறது. இந்த மொழிபெயர்ப்பைப் பயன்படுத்துவதால் ஏற்படும் எந்த தவறான புரிதல்கள் அல்லது தவறான விளக்கங்களுக்கு நாங்கள் பொறுப்பல்ல.
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**மறுப்பு**:
இந்த ஆவணம் AI மொழிபெயர்ப்பு சேவை [Co-op Translator](https://github.com/Azure/co-op-translator) பயன்படுத்தி மொழிபெயர்க்கப்பட்டுள்ளது. நாங்கள் துல்லியத்திற்காக முயற்சி செய்துள்ளோம், ஆனால் தானாக செய்யப்படும் மொழிபெயர்ப்புகளில் பிழைகள் அல்லது தவறுகள் இருக்கலாம் என்பதை கவனத்தில் கொள்ளவும். அசல் ஆவணம் அதன் தாய்மொழியில் அதிகாரப்பூர்வ ஆதாரமாக கருதப்பட வேண்டும். முக்கியமான தகவல்களுக்கு, தொழில்நுட்பமான மனித மொழிபெயர்ப்பு பரிந்துரைக்கப்படுகிறது. இந்த மொழிபெயர்ப்பைப் பயன்படுத்துவதால் ஏற்படும் எந்த தவறான புரிதல்கள் அல்லது தவறான விளக்கத்திற்கும் நாங்கள் பொறுப்பில்வில்லை.
localizeflow[bot]
7 days ago