{ "cells": [ { "cell_type": "markdown", "metadata": { "id": "rQ8UhzFpgRra" }, "source": [ "# Duomenų Paruošimas\n", "\n", "[Originalus užrašų knygelės šaltinis iš *Data Science: Introduction to Machine Learning for Data Science Python and Machine Learning Studio by Lee Stott*](https://github.com/leestott/intro-Datascience/blob/master/Course%20Materials/4-Cleaning_and_Manipulating-Reference.ipynb)\n", "\n", "## `DataFrame` informacijos tyrinėjimas\n", "\n", "> **Mokymosi tikslas:** Šios poskyrio pabaigoje turėtumėte jaustis patogiai ieškodami bendros informacijos apie duomenis, saugomus pandas `DataFrame`.\n", "\n", "Kai jau įkėlėte savo duomenis į pandas, jie greičiausiai bus `DataFrame` formatu. Tačiau, jei jūsų `DataFrame` duomenų rinkinys turi 60 000 eilučių ir 400 stulpelių, nuo ko pradėti, kad suprastumėte, su kuo dirbate? Laimei, pandas suteikia keletą patogių įrankių, leidžiančių greitai peržiūrėti bendrą informaciją apie `DataFrame`, taip pat pirmąsias ir paskutines kelias eilutes.\n", "\n", "Norėdami išbandyti šią funkcionalumą, importuosime Python scikit-learn biblioteką ir naudosime ikonišką duomenų rinkinį, kurį kiekvienas duomenų mokslininkas yra matęs šimtus kartų: britų biologo Ronaldo Fisherio *Iris* duomenų rinkinį, naudotą jo 1936 metų straipsnyje „Daugybinių matavimų naudojimas taksonomijos problemose“:\n" ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "collapsed": true, "id": "hB1RofhdgRrp", "trusted": false }, "outputs": [], "source": [ "import pandas as pd\n", "from sklearn.datasets import load_iris\n", "\n", "iris = load_iris()\n", "iris_df = pd.DataFrame(data=iris['data'], columns=iris['feature_names'])" ] }, { "cell_type": "markdown", "metadata": { "id": "AGA0A_Y8hMdz" }, "source": [ "### `DataFrame.shape`\n", "Mes įkėlėme Iris duomenų rinkinį į kintamąjį `iris_df`. Prieš pradedant analizuoti duomenis, būtų naudinga sužinoti, kiek duomenų taškų turime ir kokio dydžio yra visas duomenų rinkinys. Naudinga pažvelgti į duomenų apimtį, su kuria dirbame.\n" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "LOe5jQohhulf", "outputId": "fb0577ac-3b4a-4623-cb41-20e1b264b3e9" }, "outputs": [ { "data": { "text/plain": [ "(150, 4)" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "iris_df.shape" ] }, { "cell_type": "markdown", "metadata": { "id": "smE7AGzOhxk2" }, "source": [ "Taigi, mes turime 150 eilučių ir 4 stulpelius duomenų. Kiekviena eilutė atspindi vieną duomenų tašką, o kiekvienas stulpelis – vieną savybę, susijusią su duomenų rėmeliu. Taigi, iš esmės yra 150 duomenų taškų, kuriuose kiekviename yra po 4 savybes.\n", "\n", "`shape` čia yra duomenų rėmelio atributas, o ne funkcija, todėl jis nesibaigia skliausteliais.\n" ] }, { "cell_type": "markdown", "metadata": { "id": "d3AZKs0PinGP" }, "source": [ "### `DataFrame.columns`\n", "Dabar pereikime prie 4 duomenų stulpelių. Ką tiksliai kiekvienas iš jų reiškia? `columns` atributas suteiks mums stulpelių pavadinimus duomenų rėmelyje.\n" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "YPGh_ziji-CY", "outputId": "74e7a43a-77cc-4c80-da56-7f50767c37a0" }, "outputs": [ { "data": { "text/plain": [ "Index(['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)',\n", " 'petal width (cm)'],\n", " dtype='object')" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "iris_df.columns" ] }, { "cell_type": "markdown", "metadata": { "id": "TsobcU_VjCC_" }, "source": [ "Kaip matome, yra keturios (4) stulpeliai. `columns` atributas nurodo stulpelių pavadinimus ir iš esmės nieko daugiau. Šis atributas tampa svarbus, kai norime nustatyti, kokias savybes turi duomenų rinkinys.\n" ] }, { "cell_type": "markdown", "metadata": { "id": "2UTlvkjmgRrs" }, "source": [ "### `DataFrame.info`\n", "Duomenų kiekis (nurodytas `shape` atributu) ir savybių ar stulpelių pavadinimai (nurodyti `columns` atributu) suteikia mums tam tikrą informaciją apie duomenų rinkinį. Dabar norėtume giliau pažvelgti į duomenų rinkinį. Funkcija `DataFrame.info()` yra labai naudinga šiuo atveju.\n" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "dHHRyG0_gRrt", "outputId": "d8fb0c40-4f18-4e19-da48-c8db77d1d3a5", "trusted": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "RangeIndex: 150 entries, 0 to 149\n", "Data columns (total 4 columns):\n", " # Column Non-Null Count Dtype \n", "--- ------ -------------- ----- \n", " 0 sepal length (cm) 150 non-null float64\n", " 1 sepal width (cm) 150 non-null float64\n", " 2 petal length (cm) 150 non-null float64\n", " 3 petal width (cm) 150 non-null float64\n", "dtypes: float64(4)\n", "memory usage: 4.8 KB\n" ] } ], "source": [ "iris_df.info()" ] }, { "cell_type": "markdown", "metadata": { "id": "1XgVMpvigRru" }, "source": [ "Iš čia galime padaryti keletą pastebėjimų: \n", "1. Kiekvienos stulpelio duomenų tipas: Šiame duomenų rinkinyje visi duomenys yra saugomi kaip 64 bitų slankiojo kablelio skaičiai. \n", "2. Ne-null reikšmių skaičius: Darbas su null reikšmėmis yra svarbus duomenų paruošimo žingsnis. Tai bus aptarta vėliau užrašų knygelėje. \n" ] }, { "cell_type": "markdown", "metadata": { "id": "IYlyxbpWFEF4" }, "source": [ "### DataFrame.describe()\n", "Tarkime, turime daug skaitinių duomenų savo duomenų rinkinyje. Vieno kintamojo statistiniai skaičiavimai, tokie kaip vidurkis, mediana, kvartiliai ir pan., gali būti atliekami kiekvienai stulpeliui atskirai. Funkcija `DataFrame.describe()` pateikia statistinę santrauką apie skaitinius duomenų rinkinio stulpelius.\n" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 297 }, "id": "tWV-CMstFIRA", "outputId": "4fc49941-bc13-4b0c-a412-cb39e7d3f289" }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
sepal length (cm)sepal width (cm)petal length (cm)petal width (cm)
count150.000000150.000000150.000000150.000000
mean5.8433333.0573333.7580001.199333
std0.8280660.4358661.7652980.762238
min4.3000002.0000001.0000000.100000
25%5.1000002.8000001.6000000.300000
50%5.8000003.0000004.3500001.300000
75%6.4000003.3000005.1000001.800000
max7.9000004.4000006.9000002.500000
\n", "
" ], "text/plain": [ " sepal length (cm) sepal width (cm) petal length (cm) petal width (cm)\n", "count 150.000000 150.000000 150.000000 150.000000\n", "mean 5.843333 3.057333 3.758000 1.199333\n", "std 0.828066 0.435866 1.765298 0.762238\n", "min 4.300000 2.000000 1.000000 0.100000\n", "25% 5.100000 2.800000 1.600000 0.300000\n", "50% 5.800000 3.000000 4.350000 1.300000\n", "75% 6.400000 3.300000 5.100000 1.800000\n", "max 7.900000 4.400000 6.900000 2.500000" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "iris_df.describe()" ] }, { "cell_type": "markdown", "metadata": { "id": "zjjtW5hPGMuM" }, "source": [ "Rezultatas aukščiau rodo bendrą duomenų taškų skaičių, vidurkį, standartinį nuokrypį, minimumą, apatinį kvartilį (25%), medianą (50%), viršutinį kvartilį (75%) ir maksimalų kiekvienos stulpelio reikšmę.\n" ] }, { "cell_type": "markdown", "metadata": { "id": "-lviAu99gRrv" }, "source": [ "### `DataFrame.head`\n", "Turėdami visas aukščiau paminėtas funkcijas ir atributus, jau turime bendrą duomenų rinkinio vaizdą. Žinome, kiek yra duomenų taškų, kiek yra požymių, kokio tipo yra kiekvienas požymis ir kiek kiekvienas požymis turi nenulinių reikšmių.\n", "\n", "Dabar laikas pažvelgti į pačius duomenis. Pažiūrėkime, kaip atrodo pirmosios kelios mūsų `DataFrame` eilutės (pirmieji keli duomenų taškai):\n" ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 204 }, "id": "DZMJZh0OgRrw", "outputId": "d9393ee5-c106-4797-f815-218f17160e00", "trusted": false }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
sepal length (cm)sepal width (cm)petal length (cm)petal width (cm)
05.13.51.40.2
14.93.01.40.2
24.73.21.30.2
34.63.11.50.2
45.03.61.40.2
\n", "
" ], "text/plain": [ " sepal length (cm) sepal width (cm) petal length (cm) petal width (cm)\n", "0 5.1 3.5 1.4 0.2\n", "1 4.9 3.0 1.4 0.2\n", "2 4.7 3.2 1.3 0.2\n", "3 4.6 3.1 1.5 0.2\n", "4 5.0 3.6 1.4 0.2" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "iris_df.head()" ] }, { "cell_type": "markdown", "metadata": { "id": "EBHEimZuEFQK" }, "source": [ "Kaip matome išvestyje, čia pateikti penki (5) duomenų rinkinio įrašai. Jei pažvelgsime į indeksą kairėje, sužinosime, kad tai yra pirmosios penkios eilutės.\n" ] }, { "cell_type": "markdown", "metadata": { "id": "oj7GkrTdgRry" }, "source": [ "### Pratimas:\n", "\n", "Iš pateikto pavyzdžio aišku, kad pagal numatytuosius nustatymus `DataFrame.head` grąžina pirmas penkias `DataFrame` eilutes. Ar galite sugalvoti būdą, kaip parodyti daugiau nei penkias eilutes žemiau esančiame kodo langelyje?\n" ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "collapsed": true, "id": "EKRmRFFegRrz", "trusted": false }, "outputs": [], "source": [ "# Hint: Consult the documentation by using iris_df.head?" ] }, { "cell_type": "markdown", "metadata": { "id": "BJ_cpZqNgRr1" }, "source": [ "### `DataFrame.tail`\n", "Kitas būdas peržiūrėti duomenis yra nuo pabaigos (vietoj pradžios). Priešingybė `DataFrame.head` yra `DataFrame.tail`, kuris grąžina paskutines penkias `DataFrame` eilutes:\n" ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 0 }, "id": "heanjfGWgRr2", "outputId": "6ae09a21-fe09-4110-b0d7-1a1fbf34d7f3", "trusted": false }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
sepal length (cm)sepal width (cm)petal length (cm)petal width (cm)
1456.73.05.22.3
1466.32.55.01.9
1476.53.05.22.0
1486.23.45.42.3
1495.93.05.11.8
\n", "
" ], "text/plain": [ " sepal length (cm) sepal width (cm) petal length (cm) petal width (cm)\n", "145 6.7 3.0 5.2 2.3\n", "146 6.3 2.5 5.0 1.9\n", "147 6.5 3.0 5.2 2.0\n", "148 6.2 3.4 5.4 2.3\n", "149 5.9 3.0 5.1 1.8" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "iris_df.tail()" ] }, { "cell_type": "markdown", "metadata": { "id": "31kBWfyLgRr3" }, "source": [ "Praktiškai yra naudinga lengvai peržiūrėti pirmas kelias arba paskutines kelias `DataFrame` eilutes, ypač kai ieškote išskirtinių reikšmių tvarkinguose duomenų rinkiniuose.\n", "\n", "Visos aukščiau pateiktos funkcijos ir atributai, parodyti su kodo pavyzdžiais, padeda mums susidaryti įspūdį apie duomenis.\n", "\n", "> **Svarbiausia mintis:** Net vien pažvelgus į metaduomenis apie informaciją `DataFrame` arba į pirmas ir paskutines kelias reikšmes, galite iš karto susidaryti įspūdį apie duomenų dydį, formą ir turinį, su kuriais dirbate.\n" ] }, { "cell_type": "markdown", "metadata": { "id": "TvurZyLSDxq_" }, "source": [ "### Trūkstami Duomenys\n", "Panagrinėkime trūkstamus duomenis. Trūkstami duomenys atsiranda, kai kai kuriuose stulpeliuose nėra išsaugota jokia reikšmė.\n", "\n", "Pavyzdžiui: tarkime, kažkas yra labai susirūpinęs savo svoriu ir nepildo svorio lauko apklausoje. Tokiu atveju, to žmogaus svorio reikšmė bus trūkstama.\n", "\n", "Dažniausiai realaus pasaulio duomenų rinkiniuose pasitaiko trūkstamų reikšmių.\n", "\n", "**Kaip Pandas tvarko trūkstamus duomenis**\n", "\n", "Pandas trūkstamas reikšmes tvarko dviem būdais. Pirmasis būdas, kurį jau matėte ankstesnėse dalyse, yra `NaN`, arba Not a Number (ne skaičius). Tai iš tikrųjų yra speciali reikšmė, kuri yra IEEE slankiojo kablelio specifikacijos dalis ir naudojama tik trūkstamoms slankiojo kablelio reikšmėms nurodyti.\n", "\n", "Kitoms trūkstamoms reikšmėms, išskyrus slankiojo kablelio reikšmes, pandas naudoja Python objektą `None`. Nors gali atrodyti painu, kad susidursite su dviem skirtingais reikšmių tipais, kurie iš esmės reiškia tą patį, yra pagrįstų programavimo priežasčių, kodėl buvo pasirinktas toks dizainas. Praktikoje toks sprendimas leidžia pandas pasiekti gerą kompromisą daugeliu atvejų. Nepaisant to, tiek `None`, tiek `NaN` turi apribojimų, kuriuos reikia žinoti, atsižvelgiant į tai, kaip jie gali būti naudojami.\n" ] }, { "cell_type": "markdown", "metadata": { "id": "lOHqUlZFgRr5" }, "source": [ "### `None`: trūkstami duomenys, kurie nėra skaičiai\n", "Kadangi `None` yra iš Python, jis negali būti naudojamas NumPy ir pandas masyvuose, kurių duomenų tipas nėra `'object'`. Atminkite, kad NumPy masyvai (ir pandas duomenų struktūros) gali turėti tik vieno tipo duomenis. Tai suteikia jiems didžiulę galią dirbant su didelio masto duomenimis ir atliekant skaičiavimus, tačiau tuo pačiu apriboja jų lankstumą. Tokie masyvai turi būti perkelti į „mažiausią bendrą vardiklį“, duomenų tipą, kuris apima viską masyve. Kai masyve yra `None`, tai reiškia, kad dirbate su Python objektais.\n", "\n", "Norėdami tai pamatyti praktiškai, apsvarstykite šį pavyzdinį masyvą (atkreipkite dėmesį į jo `dtype`):\n" ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "QIoNdY4ngRr7", "outputId": "92779f18-62f4-4a03-eca2-e9a101604336", "trusted": false }, "outputs": [ { "data": { "text/plain": [ "array([2, None, 6, 8], dtype=object)" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import numpy as np\n", "\n", "example1 = np.array([2, None, 6, 8])\n", "example1" ] }, { "cell_type": "markdown", "metadata": { "id": "pdlgPNbhgRr7" }, "source": [ "Realybė, susijusi su duomenų tipų konvertavimu į aukštesnį lygį, turi dvi pasekmes. Pirma, operacijos bus vykdomos interpretuojamo Python kodo lygiu, o ne kompiliuoto NumPy kodo lygiu. Iš esmės tai reiškia, kad bet kokios operacijos, susijusios su `Series` ar `DataFrame` objektais, kuriuose yra `None`, bus lėtesnės. Nors greičiausiai šio našumo sumažėjimo nepastebėsite, didelių duomenų rinkinių atveju tai gali tapti problema.\n", "\n", "Antroji pasekmė kyla iš pirmosios. Kadangi `None` iš esmės grąžina `Series` ar `DataFrame` į paprasto Python pasaulį, naudojant NumPy/pandas agregavimo funkcijas, tokias kaip `sum()` ar `min()`, masyvuose, kuriuose yra `None` reikšmė, paprastai bus sugeneruota klaida:\n" ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 292 }, "id": "gWbx-KB9gRr8", "outputId": "ecba710a-22ec-41d5-a39c-11f67e645b50", "trusted": false }, "outputs": [ { "ename": "TypeError", "evalue": "ignored", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mexample1\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/numpy/core/_methods.py\u001b[0m in \u001b[0;36m_sum\u001b[0;34m(a, axis, dtype, out, keepdims, initial, where)\u001b[0m\n\u001b[1;32m 45\u001b[0m def _sum(a, axis=None, dtype=None, out=None, keepdims=False,\n\u001b[1;32m 46\u001b[0m initial=_NoValue, where=True):\n\u001b[0;32m---> 47\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mumr_sum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdtype\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkeepdims\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minitial\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mwhere\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 48\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 49\u001b[0m def _prod(a, axis=None, dtype=None, out=None, keepdims=False,\n", "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'int' and 'NoneType'" ] } ], "source": [ "example1.sum()" ] }, { "cell_type": "markdown", "metadata": { "id": "LcEwO8UogRr9" }, "source": [ "**Pagrindinė mintis**: Sudėtis (ir kitos operacijos) tarp sveikųjų skaičių ir `None` reikšmių yra neapibrėžta, todėl tai gali apriboti galimybes dirbti su duomenų rinkiniais, kuriuose jos yra.\n" ] }, { "cell_type": "markdown", "metadata": { "id": "pWvVHvETgRr9" }, "source": [ "### `NaN`: trūkstamos slankiojo kablelio reikšmės\n", "\n", "Skirtingai nei `None`, NumPy (ir todėl pandas) palaiko `NaN`, kad būtų galima atlikti greitas, vektorizuotas operacijas ir ufuncs. Bloga žinia yra ta, kad bet kokia aritmetika, atliekama su `NaN`, visada duoda `NaN`. Pavyzdžiui:\n" ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "rcFYfMG9gRr9", "outputId": "699e81b7-5c11-4b46-df1d-06071768690f", "trusted": false }, "outputs": [ { "data": { "text/plain": [ "nan" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.nan + 1" ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "BW3zQD2-gRr-", "outputId": "4525b6c4-495d-4f7b-a979-efce1dae9bd0", "trusted": false }, "outputs": [ { "data": { "text/plain": [ "nan" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.nan * 0" ] }, { "cell_type": "markdown", "metadata": { "id": "fU5IPRcCgRr-" }, "source": [ "Geros naujienos: agregacijos, vykdomos su masyvais, kuriuose yra `NaN`, nesukelia klaidų. Blogos naujienos: rezultatai nėra vienodai naudingi:\n" ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "LCInVgSSgRr_", "outputId": "fa06495a-0930-4867-87c5-6023031ea8b5", "trusted": false }, "outputs": [ { "data": { "text/plain": [ "(nan, nan, nan)" ] }, "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ "example2 = np.array([2, np.nan, 6, 8]) \n", "example2.sum(), example2.min(), example2.max()" ] }, { "cell_type": "markdown", "metadata": { "id": "nhlnNJT7gRr_" }, "source": [ "### Pratimas:\n" ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "collapsed": true, "id": "yan3QRaOgRr_", "trusted": false }, "outputs": [], "source": [ "# What happens if you add np.nan and None together?\n" ] }, { "cell_type": "markdown", "metadata": { "id": "_iDvIRC8gRsA" }, "source": [ "Atminkite: `NaN` yra skirtas tik trūkstamoms slankiojo kablelio reikšmėms; nėra `NaN` ekvivalento sveikiesiems skaičiams, eilutėms ar loginėms reikšmėms.\n" ] }, { "cell_type": "markdown", "metadata": { "id": "kj6EKdsAgRsA" }, "source": [ "### `NaN` ir `None`: null reikšmės pandas bibliotekoje\n", "\n", "Nors `NaN` ir `None` gali elgtis šiek tiek skirtingai, pandas biblioteka yra sukurta taip, kad su jais būtų galima dirbti kaip su lygiavertėmis reikšmėmis. Kad tai suprastume, pažiūrėkime į `Series` su sveikaisiais skaičiais:\n" ] }, { "cell_type": "code", "execution_count": 15, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "Nji-KGdNgRsA", "outputId": "36aa14d2-8efa-4bfd-c0ed-682991288822", "trusted": false }, "outputs": [ { "data": { "text/plain": [ "0 1\n", "1 2\n", "2 3\n", "dtype: int64" ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "int_series = pd.Series([1, 2, 3], dtype=int)\n", "int_series" ] }, { "cell_type": "markdown", "metadata": { "id": "WklCzqb8gRsB" }, "source": [ "### Pratimas:\n" ] }, { "cell_type": "code", "execution_count": 16, "metadata": { "collapsed": true, "id": "Cy-gqX5-gRsB", "trusted": false }, "outputs": [], "source": [ "# Now set an element of int_series equal to None.\n", "# How does that element show up in the Series?\n", "# What is the dtype of the Series?\n" ] }, { "cell_type": "markdown", "metadata": { "id": "WjMQwltNgRsB" }, "source": [ "Pandas, siekdama užtikrinti duomenų homogeniškumą `Series` ir `DataFrame` objektuose, lengvai keičia trūkstamas reikšmes tarp `None` ir `NaN`. Dėl šios dizaino ypatybės naudinga galvoti apie `None` ir `NaN` kaip apie dvi skirtingas „null“ reikšmių formas pandas bibliotekoje. Iš tiesų, kai kurie pagrindiniai metodai, kuriuos naudosite tvarkydami trūkstamas reikšmes pandas, atspindi šią idėją savo pavadinimuose:\n", "\n", "- `isnull()`: Sukuria loginę kaukę, nurodančią trūkstamas reikšmes\n", "- `notnull()`: Priešingas `isnull()`\n", "- `dropna()`: Grąžina filtruotą duomenų versiją\n", "- `fillna()`: Grąžina duomenų kopiją su užpildytomis arba įterptomis trūkstamomis reikšmėmis\n", "\n", "Šie metodai yra labai svarbūs, todėl verta juos gerai išmokti ir jaustis patogiai juos naudojant. Dabar išsamiau aptarkime kiekvieną iš jų.\n" ] }, { "cell_type": "markdown", "metadata": { "id": "Yh5ifd9FgRsB" }, "source": [ "### Nustatyti null reikšmes\n", "\n", "Dabar, kai supratome trūkstamų reikšmių svarbą, turime jas nustatyti savo duomenų rinkinyje, prieš pradėdami jas tvarkyti. \n", "Tiek `isnull()`, tiek `notnull()` yra pagrindiniai metodai, skirti nustatyti null duomenis. Abu grąžina Boole'o kaukes jūsų duomenims.\n" ] }, { "cell_type": "code", "execution_count": 17, "metadata": { "collapsed": true, "id": "e-vFp5lvgRsC", "trusted": false }, "outputs": [], "source": [ "example3 = pd.Series([0, np.nan, '', None])" ] }, { "cell_type": "code", "execution_count": 18, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "1XdaJJ7PgRsC", "outputId": "92fc363a-1874-471f-846d-f4f9ce1f51d0", "trusted": false }, "outputs": [ { "data": { "text/plain": [ "0 False\n", "1 True\n", "2 False\n", "3 True\n", "dtype: bool" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ "example3.isnull()" ] }, { "cell_type": "markdown", "metadata": { "id": "PaSZ0SQygRsC" }, "source": [ "Ar atidžiai pažvelgėte į rezultatą? Ar kas nors jus nustebino? Nors `0` yra aritmetinis nulis, jis vis tiek yra visiškai tinkamas sveikasis skaičius, ir pandas jį taip ir traktuoja. `''` yra šiek tiek subtilesnis atvejis. Nors 1 skyriuje jį naudojome kaip tuščios eilutės reikšmę, vis dėlto tai yra eilutės objektas, o ne null reprezentacija pandas požiūriu.\n", "\n", "Dabar apverskime situaciją ir naudokime šiuos metodus taip, kaip juos naudosite praktiškai. Boolean kaukes galite naudoti tiesiogiai kaip ``Series`` arba ``DataFrame`` indeksą, kas gali būti naudinga dirbant su izoliuotomis trūkstamomis (arba esamomis) reikšmėmis.\n", "\n", "Jei norime gauti bendrą trūkstamų reikšmių skaičių, galime tiesiog atlikti sumą pagal kaukę, kurią sukuria `isnull()` metodas.\n" ] }, { "cell_type": "code", "execution_count": 19, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "JCcQVoPkHDUv", "outputId": "001daa72-54f8-4bd5-842a-4df627a79d4d" }, "outputs": [ { "data": { "text/plain": [ "2" ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ "example3.isnull().sum()" ] }, { "cell_type": "markdown", "metadata": { "id": "PlBqEo3mgRsC" }, "source": [ "### Pratimas:\n" ] }, { "cell_type": "code", "execution_count": 20, "metadata": { "collapsed": true, "id": "ggDVf5uygRsD", "trusted": false }, "outputs": [], "source": [ "# Try running example3[example3.notnull()].\n", "# Before you do so, what do you expect to see?\n" ] }, { "cell_type": "markdown", "metadata": { "id": "D_jWN7mHgRsD" }, "source": [ "**Pagrindinė mintis**: Tiek `isnull()`, tiek `notnull()` metodai duoda panašius rezultatus, kai juos naudojate „DataFrame“: jie parodo rezultatus ir tų rezultatų indeksą, kas labai padės jums dirbant su savo duomenimis.\n" ] }, { "cell_type": "markdown", "metadata": { "id": "BvnoojWsgRr4" }, "source": [ "### Darbas su trūkstamais duomenimis\n", "\n", "> **Mokymosi tikslas:** Šio poskyrio pabaigoje turėtumėte žinoti, kaip ir kada pakeisti arba pašalinti null reikšmes iš DataFrame.\n", "\n", "Mašininio mokymosi modeliai patys negali apdoroti trūkstamų duomenų. Todėl prieš perduodant duomenis modeliui, turime išspręsti šių trūkstamų reikšmių problemą.\n", "\n", "Kaip tvarkomi trūkstami duomenys, turi subtilių kompromisų, kurie gali paveikti jūsų galutinę analizę ir realaus pasaulio rezultatus.\n", "\n", "Yra du pagrindiniai būdai, kaip spręsti trūkstamų duomenų problemą:\n", "\n", "1. Pašalinti eilutę, kurioje yra trūkstama reikšmė\n", "2. Pakeisti trūkstamą reikšmę kita reikšme\n", "\n", "Mes aptarsime abu šiuos metodus ir jų privalumus bei trūkumus išsamiai.\n" ] }, { "cell_type": "markdown", "metadata": { "id": "3VaYC1TvgRsD" }, "source": [ "### Null reikšmių pašalinimas\n", "\n", "Duomenų kiekis, kurį perduodame savo modeliui, tiesiogiai veikia jo našumą. Pašalinus null reikšmes, sumažiname duomenų taškų skaičių, o kartu ir duomenų rinkinio dydį. Todėl rekomenduojama pašalinti eilutes su null reikšmėmis, kai duomenų rinkinys yra pakankamai didelis.\n", "\n", "Kitas atvejis gali būti, kai tam tikra eilutė ar stulpelis turi daug trūkstamų reikšmių. Tokiu atveju jie gali būti pašalinti, nes jie nepridės daug vertės mūsų analizei, kadangi didžioji dalis duomenų toje eilutėje/stulpelyje yra trūkstama.\n", "\n", "Be trūkstamų reikšmių identifikavimo, pandas suteikia patogų būdą pašalinti null reikšmes iš `Series` ir `DataFrame`. Kad pamatytume, kaip tai veikia, grįžkime prie `example3`. Funkcija `DataFrame.dropna()` padeda pašalinti eilutes su null reikšmėmis.\n" ] }, { "cell_type": "code", "execution_count": 21, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "7uIvS097gRsD", "outputId": "c13fc117-4ca1-4145-a0aa-42ac89e6e218", "trusted": false }, "outputs": [ { "data": { "text/plain": [ "0 0\n", "2 \n", "dtype: object" ] }, "execution_count": 21, "metadata": {}, "output_type": "execute_result" } ], "source": [ "example3 = example3.dropna()\n", "example3" ] }, { "cell_type": "markdown", "metadata": { "id": "hil2cr64gRsD" }, "source": [ "Atkreipkite dėmesį, kad tai turėtų atrodyti kaip jūsų išvestis iš `example3[example3.notnull()]`. Skirtumas čia yra tas, kad vietoj tiesiog indeksavimo pagal užmaskuotas reikšmes, `dropna` pašalino tas trūkstamas reikšmes iš `Series` `example3`.\n", "\n", "Kadangi DataFrames turi dvi dimensijas, jie suteikia daugiau galimybių duomenims pašalinti.\n" ] }, { "cell_type": "code", "execution_count": 22, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 142 }, "id": "an-l74sPgRsE", "outputId": "340876a0-63ad-40f6-bd54-6240cdae50ab", "trusted": false }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
012
01.0NaN7
12.05.08
2NaN6.09
\n", "
" ], "text/plain": [ " 0 1 2\n", "0 1.0 NaN 7\n", "1 2.0 5.0 8\n", "2 NaN 6.0 9" ] }, "execution_count": 22, "metadata": {}, "output_type": "execute_result" } ], "source": [ "example4 = pd.DataFrame([[1, np.nan, 7], \n", " [2, 5, 8], \n", " [np.nan, 6, 9]])\n", "example4" ] }, { "cell_type": "markdown", "metadata": { "id": "66wwdHZrgRsE" }, "source": [ "(Ar pastebėjote, kad pandas pakeitė dviejų stulpelių tipą į float, kad būtų galima įtraukti `NaN`?)\n", "\n", "Negalite pašalinti vienos reikšmės iš `DataFrame`, todėl turite pašalinti visas eilutes arba stulpelius. Priklausomai nuo to, ką darote, galite pasirinkti vieną ar kitą variantą, todėl pandas suteikia galimybes abiem. Kadangi duomenų moksle stulpeliai paprastai atspindi kintamuosius, o eilutės – stebėjimus, dažniau pašalinamos duomenų eilutės; numatytasis `dropna()` nustatymas yra pašalinti visas eilutes, kuriose yra bet kokių null reikšmių:\n" ] }, { "cell_type": "code", "execution_count": 23, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 80 }, "id": "jAVU24RXgRsE", "outputId": "0b5e5aee-7187-4d3f-b583-a44136ae5f80", "trusted": false }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
012
12.05.08
\n", "
" ], "text/plain": [ " 0 1 2\n", "1 2.0 5.0 8" ] }, "execution_count": 23, "metadata": {}, "output_type": "execute_result" } ], "source": [ "example4.dropna()" ] }, { "cell_type": "markdown", "metadata": { "id": "TrQRBuTDgRsE" }, "source": [ "Jei reikia, galite pašalinti NA reikšmes iš stulpelių. Naudokite `axis=1`, kad tai padarytumėte:\n" ] }, { "cell_type": "code", "execution_count": 24, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 142 }, "id": "GrBhxu9GgRsE", "outputId": "ff4001f3-2e61-4509-d60e-0093d1068437", "trusted": false }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
2
07
18
29
\n", "
" ], "text/plain": [ " 2\n", "0 7\n", "1 8\n", "2 9" ] }, "execution_count": 24, "metadata": {}, "output_type": "execute_result" } ], "source": [ "example4.dropna(axis='columns')" ] }, { "cell_type": "markdown", "metadata": { "id": "KWXiKTfMgRsF" }, "source": [ "Atkreipkite dėmesį, kad tai gali pašalinti daug duomenų, kuriuos galbūt norėtumėte išsaugoti, ypač mažesniuose duomenų rinkiniuose. O kas, jei norite pašalinti tik tas eilutes ar stulpelius, kuriuose yra kelios arba net visos null reikšmės? Šiuos nustatymus galite nurodyti `dropna` funkcijoje naudodami `how` ir `thresh` parametrus.\n", "\n", "Pagal numatytuosius nustatymus `how='any'` (jei norite patys patikrinti arba pamatyti, kokius kitus parametrus metodas turi, paleiskite `example4.dropna?` kodo langelyje). Taip pat galite nurodyti `how='all`, kad būtų pašalintos tik tos eilutės ar stulpeliai, kuriuose yra visos null reikšmės. Išplėskime mūsų pavyzdinį `DataFrame`, kad pamatytume tai veikiant kitame pratime.\n" ] }, { "cell_type": "code", "execution_count": 25, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 142 }, "id": "Bcf_JWTsgRsF", "outputId": "72e0b1b8-52fa-4923-98ce-b6fbed6e44b1", "trusted": false }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
0123
01.0NaN7NaN
12.05.08NaN
2NaN6.09NaN
\n", "
" ], "text/plain": [ " 0 1 2 3\n", "0 1.0 NaN 7 NaN\n", "1 2.0 5.0 8 NaN\n", "2 NaN 6.0 9 NaN" ] }, "execution_count": 25, "metadata": {}, "output_type": "execute_result" } ], "source": [ "example4[3] = np.nan\n", "example4" ] }, { "cell_type": "markdown", "metadata": { "id": "pNZer7q9JPNC" }, "source": [ "> Pagrindinės mintys: \n", "1. Naudinga pašalinti null reikšmes tik tada, jei duomenų rinkinys yra pakankamai didelis. \n", "2. Pilnas eilutes arba stulpelius galima pašalinti, jei dauguma jų duomenų trūksta. \n", "3. Metodas `DataFrame.dropna(axis=)` padeda pašalinti null reikšmes. Argumentas `axis` nurodo, ar reikia pašalinti eilutes, ar stulpelius. \n", "4. Taip pat galima naudoti argumentą `how`. Pagal numatytuosius nustatymus jis nustatytas į `any`. Tai reiškia, kad bus pašalintos tik tos eilutės/stulpeliai, kuriuose yra bet kokių null reikšmių. Jį galima nustatyti į `all`, kad būtų pašalintos tik tos eilutės/stulpeliai, kur visi duomenys yra null. \n" ] }, { "cell_type": "markdown", "metadata": { "id": "oXXSfQFHgRsF" }, "source": [ "### Pratimas:\n" ] }, { "cell_type": "code", "execution_count": 22, "metadata": { "collapsed": true, "id": "ExUwQRxpgRsF", "trusted": false }, "outputs": [], "source": [ "# How might you go about dropping just column 3?\n", "# Hint: remember that you will need to supply both the axis parameter and the how parameter.\n" ] }, { "cell_type": "markdown", "metadata": { "id": "38kwAihWgRsG" }, "source": [ "`thresh` parametras suteikia jums smulkesnę kontrolę: jūs nustatote *ne-null* reikšmių skaičių, kurį eilutė arba stulpelis turi turėti, kad būtų išsaugotas:\n" ] }, { "cell_type": "code", "execution_count": 27, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 80 }, "id": "M9dCNMaagRsG", "outputId": "8093713a-54d2-4e54-c73f-4eea315cb6f2", "trusted": false }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
0123
12.05.08NaN
\n", "
" ], "text/plain": [ " 0 1 2 3\n", "1 2.0 5.0 8 NaN" ] }, "execution_count": 27, "metadata": {}, "output_type": "execute_result" } ], "source": [ "example4.dropna(axis='rows', thresh=3)" ] }, { "cell_type": "markdown", "metadata": { "id": "fmSFnzZegRsG" }, "source": [ "Čia pirmoji ir paskutinė eilutės buvo pašalintos, nes jos turi tik dvi nenull reikšmes.\n" ] }, { "cell_type": "markdown", "metadata": { "id": "mCcxLGyUgRsG" }, "source": [ "### Užpildyti null reikšmes\n", "\n", "Kartais yra prasminga užpildyti trūkstamas reikšmes tokiomis, kurios galėtų būti tinkamos. Yra keletas būdų, kaip užpildyti null reikšmes. Pirmasis būdas – naudoti Srities Žinias (žinias apie temą, kuria pagrįstas duomenų rinkinys), kad kažkaip apytiksliai nustatytumėte trūkstamas reikšmes.\n", "\n", "Galite naudoti `isnull`, kad tai atliktumėte vietoje, tačiau tai gali būti varginantis procesas, ypač jei turite daug reikšmių, kurias reikia užpildyti. Kadangi tai yra labai dažna užduotis duomenų moksle, pandas siūlo `fillna`, kuris grąžina `Series` arba `DataFrame` kopiją su trūkstamomis reikšmėmis, pakeistomis jūsų pasirinktomis reikšmėmis. Sukurkime kitą `Series` pavyzdį, kad pamatytume, kaip tai veikia praktiškai.\n" ] }, { "cell_type": "markdown", "metadata": { "id": "CE8S7louLezV" }, "source": [ "### Kategoriniai duomenys (ne skaitiniai)\n", "Pirmiausia aptarkime ne skaitinius duomenis. Duomenų rinkiniuose turime stulpelius su kategoriniais duomenimis. Pvz., lytis, Tiesa arba Klaidinga ir pan.\n", "\n", "Daugeliu atvejų trūkstamas reikšmes pakeičiame stulpelio `moda`. Tarkime, turime 100 duomenų taškų, iš kurių 90 nurodė Tiesa, 8 nurodė Klaidinga, o 2 neatsakė. Tuomet tuos 2 galime užpildyti Tiesa, atsižvelgdami į visą stulpelį.\n", "\n", "Vėlgi, čia galime pasinaudoti srities žiniomis. Pažvelkime į pavyzdį, kaip užpildyti naudojant modą.\n" ] }, { "cell_type": "code", "execution_count": 28, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 204 }, "id": "MY5faq4yLdpQ", "outputId": "19ab472e-1eed-4de8-f8a7-db2a3af3cb1a" }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
012
012True
134None
256False
378True
4910True
\n", "
" ], "text/plain": [ " 0 1 2\n", "0 1 2 True\n", "1 3 4 None\n", "2 5 6 False\n", "3 7 8 True\n", "4 9 10 True" ] }, "execution_count": 28, "metadata": {}, "output_type": "execute_result" } ], "source": [ "fill_with_mode = pd.DataFrame([[1,2,\"True\"],\n", " [3,4,None],\n", " [5,6,\"False\"],\n", " [7,8,\"True\"],\n", " [9,10,\"True\"]])\n", "\n", "fill_with_mode" ] }, { "cell_type": "markdown", "metadata": { "id": "MLAoMQOfNPlA" }, "source": [] }, { "cell_type": "code", "execution_count": 29, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "WKy-9Y2tN5jv", "outputId": "8da9fa16-e08c-447e-dea1-d4b1db2feebf" }, "outputs": [ { "data": { "text/plain": [ "True 3\n", "False 1\n", "Name: 2, dtype: int64" ] }, "execution_count": 29, "metadata": {}, "output_type": "execute_result" } ], "source": [ "fill_with_mode[2].value_counts()" ] }, { "cell_type": "markdown", "metadata": { "id": "6iNz_zG_OKrx" }, "source": [] }, { "cell_type": "code", "execution_count": 30, "metadata": { "id": "TxPKteRvNPOs" }, "outputs": [], "source": [ "fill_with_mode[2].fillna('True',inplace=True)" ] }, { "cell_type": "code", "execution_count": 31, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 204 }, "id": "tvas7c9_OPWE", "outputId": "ec3c8e44-d644-475e-9e22-c65101965850" }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
012
012True
134True
256False
378True
4910True
\n", "
" ], "text/plain": [ " 0 1 2\n", "0 1 2 True\n", "1 3 4 True\n", "2 5 6 False\n", "3 7 8 True\n", "4 9 10 True" ] }, "execution_count": 31, "metadata": {}, "output_type": "execute_result" } ], "source": [ "fill_with_mode" ] }, { "cell_type": "markdown", "metadata": { "id": "SktitLxxOR16" }, "source": [ "Kaip matome, null reikšmė buvo pakeista. Nereikia nė sakyti, kad galėjome parašyti bet ką vietoje `'True'` ir tai būtų buvę pakeista.\n" ] }, { "cell_type": "markdown", "metadata": { "id": "heYe1I0dOmQ_" }, "source": [ "### Skaitiniai duomenys\n", "Dabar pereikime prie skaitinių duomenų. Čia turime du įprastus būdus, kaip pakeisti trūkstamas reikšmes:\n", "\n", "1. Pakeisti eilutės medianos reikšme \n", "2. Pakeisti eilutės vidurkiu \n", "\n", "Mediana naudojama, kai duomenys yra iškreipti ir turi išskirčių. Taip yra todėl, kad mediana yra atspari išskirtims.\n", "\n", "Kai duomenys yra normalizuoti, galime naudoti vidurkį, nes tokiu atveju vidurkis ir mediana bus gana panašūs.\n", "\n", "Pirmiausia paimkime stulpelį, kuris yra normaliai pasiskirstęs, ir užpildykime trūkstamą reikšmę stulpelio vidurkiu.\n" ] }, { "cell_type": "code", "execution_count": 32, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 204 }, "id": "09HM_2feOj5Y", "outputId": "7e309013-9acb-411c-9b06-4de795bbeeff" }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
012
0-2.001
1-1.023
2NaN45
31.067
42.089
\n", "
" ], "text/plain": [ " 0 1 2\n", "0 -2.0 0 1\n", "1 -1.0 2 3\n", "2 NaN 4 5\n", "3 1.0 6 7\n", "4 2.0 8 9" ] }, "execution_count": 32, "metadata": {}, "output_type": "execute_result" } ], "source": [ "fill_with_mean = pd.DataFrame([[-2,0,1],\n", " [-1,2,3],\n", " [np.nan,4,5],\n", " [1,6,7],\n", " [2,8,9]])\n", "\n", "fill_with_mean" ] }, { "cell_type": "markdown", "metadata": { "id": "ka7-wNfzSxbx" }, "source": [ "Stulpelio vidurkis yra\n" ] }, { "cell_type": "code", "execution_count": 33, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "XYtYEf5BSxFL", "outputId": "68a78d18-f0e5-4a9a-a959-2c3676a57c70" }, "outputs": [ { "data": { "text/plain": [ "0.0" ] }, "execution_count": 33, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.mean(fill_with_mean[0])" ] }, { "cell_type": "markdown", "metadata": { "id": "oBSRGxKRS39K" }, "source": [] }, { "cell_type": "code", "execution_count": 34, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 204 }, "id": "FzncQLmuS5jh", "outputId": "00f74fff-01f4-4024-c261-796f50f01d2e" }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
012
0-2.001
1-1.023
20.045
31.067
42.089
\n", "
" ], "text/plain": [ " 0 1 2\n", "0 -2.0 0 1\n", "1 -1.0 2 3\n", "2 0.0 4 5\n", "3 1.0 6 7\n", "4 2.0 8 9" ] }, "execution_count": 34, "metadata": {}, "output_type": "execute_result" } ], "source": [ "fill_with_mean[0].fillna(np.mean(fill_with_mean[0]),inplace=True)\n", "fill_with_mean" ] }, { "cell_type": "markdown", "metadata": { "id": "CwpVFCrPTC5z" }, "source": [ "Kaip matome, trūkstama reikšmė buvo pakeista jos vidurkiu.\n" ] }, { "cell_type": "markdown", "metadata": { "id": "jIvF13a1i00Z" }, "source": [ "Dabar išbandykime kitą duomenų rėmelį, ir šį kartą pakeisime None reikšmes stulpelio mediana.\n" ] }, { "cell_type": "code", "execution_count": 35, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 204 }, "id": "DA59Bqo3jBYZ", "outputId": "85dae6ec-7394-4c36-fda0-e04769ec4a32" }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
012
0-20.01
1-12.03
20NaN5
316.07
428.09
\n", "
" ], "text/plain": [ " 0 1 2\n", "0 -2 0.0 1\n", "1 -1 2.0 3\n", "2 0 NaN 5\n", "3 1 6.0 7\n", "4 2 8.0 9" ] }, "execution_count": 35, "metadata": {}, "output_type": "execute_result" } ], "source": [ "fill_with_median = pd.DataFrame([[-2,0,1],\n", " [-1,2,3],\n", " [0,np.nan,5],\n", " [1,6,7],\n", " [2,8,9]])\n", "\n", "fill_with_median" ] }, { "cell_type": "markdown", "metadata": { "id": "mM1GpXYmjHnc" }, "source": [ "Antrosios stulpelio mediana yra\n" ] }, { "cell_type": "code", "execution_count": 36, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "uiDy5v3xjHHX", "outputId": "564b6b74-2004-4486-90d4-b39330a64b88" }, "outputs": [ { "data": { "text/plain": [ "4.0" ] }, "execution_count": 36, "metadata": {}, "output_type": "execute_result" } ], "source": [ "fill_with_median[1].median()" ] }, { "cell_type": "markdown", "metadata": { "id": "z9PLF75Jj_1s" }, "source": [] }, { "cell_type": "code", "execution_count": 37, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 204 }, "id": "lFKbOxCMkBbg", "outputId": "a8bd18fb-2765-47d4-e5fe-e965f57ed1f4" }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
012
0-20.01
1-12.03
204.05
316.07
428.09
\n", "
" ], "text/plain": [ " 0 1 2\n", "0 -2 0.0 1\n", "1 -1 2.0 3\n", "2 0 4.0 5\n", "3 1 6.0 7\n", "4 2 8.0 9" ] }, "execution_count": 37, "metadata": {}, "output_type": "execute_result" } ], "source": [ "fill_with_median[1].fillna(fill_with_median[1].median(),inplace=True)\n", "fill_with_median" ] }, { "cell_type": "markdown", "metadata": { "id": "8JtQ53GSkKWC" }, "source": [ "Kaip matome, NaN reikšmė buvo pakeista stulpelio mediana\n" ] }, { "cell_type": "code", "execution_count": 38, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "0ybtWLDdgRsG", "outputId": "b8c238ef-6024-4ee2-be2b-aa1f0fcac61d", "trusted": false }, "outputs": [ { "data": { "text/plain": [ "a 1.0\n", "b NaN\n", "c 2.0\n", "d NaN\n", "e 3.0\n", "dtype: float64" ] }, "execution_count": 38, "metadata": {}, "output_type": "execute_result" } ], "source": [ "example5 = pd.Series([1, np.nan, 2, None, 3], index=list('abcde'))\n", "example5" ] }, { "cell_type": "markdown", "metadata": { "id": "yrsigxRggRsH" }, "source": [ "Galite užpildyti visas tuščias reikšmes viena verte, pavyzdžiui, `0`:\n" ] }, { "cell_type": "code", "execution_count": 39, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "KXMIPsQdgRsH", "outputId": "aeedfa0a-a421-4c2f-cb0d-183ce8f0c91d", "trusted": false }, "outputs": [ { "data": { "text/plain": [ "a 1.0\n", "b 0.0\n", "c 2.0\n", "d 0.0\n", "e 3.0\n", "dtype: float64" ] }, "execution_count": 39, "metadata": {}, "output_type": "execute_result" } ], "source": [ "example5.fillna(0)" ] }, { "cell_type": "markdown", "metadata": { "id": "RRlI5f_hkfKe" }, "source": [ "> Pagrindinės įžvalgos: \n", "1. Trūkstamas reikšmes reikėtų užpildyti, kai duomenų yra mažai arba kai yra strategija, kaip užpildyti trūkstamus duomenis. \n", "2. Trūkstamas reikšmes galima užpildyti remiantis srities žiniomis, jas apytiksliai įvertinant. \n", "3. Kategoriniams duomenims dažniausiai trūkstamos reikšmės pakeičiamos stulpelio moda. \n", "4. Skaitiniams duomenims trūkstamos reikšmės paprastai užpildomos stulpelio vidurkiu (normalizuotų duomenų atveju) arba mediana. \n" ] }, { "cell_type": "markdown", "metadata": { "id": "FI9MmqFJgRsH" }, "source": [ "### Pratimas:\n" ] }, { "cell_type": "code", "execution_count": 40, "metadata": { "collapsed": true, "id": "af-ezpXdgRsH", "trusted": false }, "outputs": [], "source": [ "# What happens if you try to fill null values with a string, like ''?\n" ] }, { "cell_type": "markdown", "metadata": { "id": "kq3hw1kLgRsI" }, "source": [ "Jūs galite **užpildyti pirmyn** null reikšmes, naudodami paskutinę galiojančią reikšmę null reikšmei užpildyti:\n" ] }, { "cell_type": "code", "execution_count": 41, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "vO3BuNrggRsI", "outputId": "e2bc591b-0b48-4e88-ee65-754f2737c196", "trusted": false }, "outputs": [ { "data": { "text/plain": [ "a 1.0\n", "b 1.0\n", "c 2.0\n", "d 2.0\n", "e 3.0\n", "dtype: float64" ] }, "execution_count": 41, "metadata": {}, "output_type": "execute_result" } ], "source": [ "example5.fillna(method='ffill')" ] }, { "cell_type": "markdown", "metadata": { "id": "nDXeYuHzgRsI" }, "source": [ "Jūs taip pat galite **atgal užpildyti**, kad paskleistumėte kitą galiojančią reikšmę atgal, užpildydami nulį:\n" ] }, { "cell_type": "code", "execution_count": 42, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "4M5onHcEgRsI", "outputId": "8f32b185-40dd-4a9f-bd85-54d6b6a414fe", "trusted": false }, "outputs": [ { "data": { "text/plain": [ "a 1.0\n", "b 2.0\n", "c 2.0\n", "d 3.0\n", "e 3.0\n", "dtype: float64" ] }, "execution_count": 42, "metadata": {}, "output_type": "execute_result" } ], "source": [ "example5.fillna(method='bfill')" ] }, { "cell_type": "markdown", "metadata": { "collapsed": true, "id": "MbBzTom5gRsI" }, "source": [ "Kaip galite spėti, tai veikia taip pat su „DataFrames“, tačiau taip pat galite nurodyti `axis`, pagal kurį užpildyti null reikšmes:\n" ] }, { "cell_type": "code", "execution_count": 43, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 142 }, "id": "aRpIvo4ZgRsI", "outputId": "905a980a-a808-4eca-d0ba-224bd7d85955", "trusted": false }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
0123
01.0NaN7NaN
12.05.08NaN
2NaN6.09NaN
\n", "
" ], "text/plain": [ " 0 1 2 3\n", "0 1.0 NaN 7 NaN\n", "1 2.0 5.0 8 NaN\n", "2 NaN 6.0 9 NaN" ] }, "execution_count": 43, "metadata": {}, "output_type": "execute_result" } ], "source": [ "example4" ] }, { "cell_type": "code", "execution_count": 44, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 142 }, "id": "VM1qtACAgRsI", "outputId": "71f2ad28-9b4e-4ff4-f5c3-e731eb489ade", "trusted": false }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
0123
01.01.07.07.0
12.05.08.08.0
2NaN6.09.09.0
\n", "
" ], "text/plain": [ " 0 1 2 3\n", "0 1.0 1.0 7.0 7.0\n", "1 2.0 5.0 8.0 8.0\n", "2 NaN 6.0 9.0 9.0" ] }, "execution_count": 44, "metadata": {}, "output_type": "execute_result" } ], "source": [ "example4.fillna(method='ffill', axis=1)" ] }, { "cell_type": "markdown", "metadata": { "id": "ZeMc-I1EgRsI" }, "source": [ "Atkreipkite dėmesį, kad kai ankstesnė reikšmė nėra prieinama užpildymui į priekį, null reikšmė lieka.\n" ] }, { "cell_type": "markdown", "metadata": { "id": "eeAoOU0RgRsJ" }, "source": [ "### Pratimas:\n" ] }, { "cell_type": "code", "execution_count": 45, "metadata": { "collapsed": true, "id": "e8S-CjW8gRsJ", "trusted": false }, "outputs": [], "source": [ "# What output does example4.fillna(method='bfill', axis=1) produce?\n", "# What about example4.fillna(method='ffill') or example4.fillna(method='bfill')?\n", "# Can you think of a longer code snippet to write that can fill all of the null values in example4?\n" ] }, { "cell_type": "markdown", "metadata": { "id": "YHgy0lIrgRsJ" }, "source": [ "Galite kūrybiškai naudoti `fillna`. Pavyzdžiui, pažvelkime į `example4` dar kartą, tačiau šį kartą užpildykime trūkstamas reikšmes visų `DataFrame` reikšmių vidurkiu:\n" ] }, { "cell_type": "code", "execution_count": 46, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 142 }, "id": "OtYVErEygRsJ", "outputId": "708b1e67-45ca-44bf-a5ee-8b2de09ece73", "trusted": false }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
0123
01.05.57NaN
12.05.08NaN
21.56.09NaN
\n", "
" ], "text/plain": [ " 0 1 2 3\n", "0 1.0 5.5 7 NaN\n", "1 2.0 5.0 8 NaN\n", "2 1.5 6.0 9 NaN" ] }, "execution_count": 46, "metadata": {}, "output_type": "execute_result" } ], "source": [ "example4.fillna(example4.mean())" ] }, { "cell_type": "markdown", "metadata": { "id": "zpMvCkLSgRsJ" }, "source": [ "Atkreipkite dėmesį, kad trečioje stulpelyje vis dar nėra reikšmių: numatytoji kryptis yra užpildyti reikšmes eilutėmis.\n", "\n", "> **Svarbiausia mintis:** Yra daugybė būdų, kaip spręsti trūkstamų reikšmių problemą jūsų duomenų rinkiniuose. Konkreti strategija, kurią pasirinksite (pašalinimas, pakeitimas ar net tai, kaip pakeisite), turėtų būti diktuojama konkrečiais duomenų ypatumais. Kuo daugiau dirbsite su duomenų rinkiniais ir juos analizuosite, tuo geriau suprasite, kaip elgtis su trūkstamomis reikšmėmis.\n" ] }, { "cell_type": "markdown", "metadata": { "id": "bauDnESIl9FH" }, "source": [ "### Kategorinių duomenų kodavimas\n", "\n", "Mašininio mokymosi modeliai dirba tik su skaičiais ir bet kokia skaitine informacija. Jie negali atskirti „Taip“ nuo „Ne“, tačiau gali atskirti 0 nuo 1. Todėl, užpildžius trūkstamas reikšmes, turime koduoti kategorinius duomenis į tam tikrą skaitinę formą, kad modelis juos suprastų.\n", "\n", "Kodavimą galima atlikti dviem būdais. Toliau aptarsime juos.\n" ] }, { "cell_type": "markdown", "metadata": { "id": "uDq9SxB7mu5i" }, "source": [ "**ŽYMĖS KODAVIMAS**\n", "\n", "Žymės kodavimas iš esmės reiškia kiekvienos kategorijos pavertimą skaičiumi. Pavyzdžiui, tarkime, turime oro linijų keleivių duomenų rinkinį, kuriame yra stulpelis su jų klase iš šių variantų: ['verslo klasė', 'ekonominė klasė', 'pirmoji klasė']. Jei būtų atliktas žymės kodavimas, tai būtų paversta į [0,1,2]. Pažiūrėkime pavyzdį per kodą. Kadangi artimiausiuose užrašuose mokysimės naudoti `scikit-learn`, čia jo nenaudosime.\n" ] }, { "cell_type": "code", "execution_count": 47, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 235 }, "id": "1vGz7uZyoWHL", "outputId": "9e252855-d193-4103-a54d-028ea7787b34" }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
IDclass
010business class
120first class
230economy class
340economy class
450economy class
560business class
\n", "
" ], "text/plain": [ " ID class\n", "0 10 business class\n", "1 20 first class\n", "2 30 economy class\n", "3 40 economy class\n", "4 50 economy class\n", "5 60 business class" ] }, "execution_count": 47, "metadata": {}, "output_type": "execute_result" } ], "source": [ "label = pd.DataFrame([\n", " [10,'business class'],\n", " [20,'first class'],\n", " [30, 'economy class'],\n", " [40, 'economy class'],\n", " [50, 'economy class'],\n", " [60, 'business class']\n", "],columns=['ID','class'])\n", "label" ] }, { "cell_type": "markdown", "metadata": { "id": "IDHnkwTYov-h" }, "source": [ "Norėdami atlikti etikečių kodavimą pirmoje stulpelyje, pirmiausia turime aprašyti kiekvienos klasės susiejimą su skaičiumi, prieš pakeičiant.\n" ] }, { "cell_type": "code", "execution_count": 48, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 235 }, "id": "ZC5URJG3o1ES", "outputId": "aab0f1e7-e0f3-4c14-8459-9f9168c85437" }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
IDclass
0100
1202
2301
3401
4501
5600
\n", "
" ], "text/plain": [ " ID class\n", "0 10 0\n", "1 20 2\n", "2 30 1\n", "3 40 1\n", "4 50 1\n", "5 60 0" ] }, "execution_count": 48, "metadata": {}, "output_type": "execute_result" } ], "source": [ "class_labels = {'business class':0,'economy class':1,'first class':2}\n", "label['class'] = label['class'].replace(class_labels)\n", "label" ] }, { "cell_type": "markdown", "metadata": { "id": "ftnF-TyapOPt" }, "source": [ "Kaip matome, rezultatas atitinka tai, ką tikėjomės. Taigi, kada naudojame etikečių kodavimą? Etikečių kodavimas naudojamas vienu ar abiem šiais atvejais:\n", "1. Kai kategorijų skaičius yra didelis\n", "2. Kai kategorijos yra tvarkoje.\n" ] }, { "cell_type": "markdown", "metadata": { "id": "eQPAPVwsqWT7" }, "source": [ "**VIENKARTINIS KODAVIMAS**\n", "\n", "Kitas kodavimo tipas yra vienkartinis kodavimas (One Hot Encoding). Šio tipo kodavime kiekviena stulpelio kategorija pridedama kaip atskiras stulpelis, o kiekvienam duomenų taškui priskiriama 0 arba 1, priklausomai nuo to, ar jis priklauso tai kategorijai. Taigi, jei yra n skirtingų kategorijų, prie duomenų rėmelio bus pridėti n stulpeliai.\n", "\n", "Pavyzdžiui, paimkime tą patį lėktuvo klasių pavyzdį. Kategorijos buvo: ['verslo klasė', 'ekonominė klasė', 'pirmoji klasė']. Taigi, jei atliksime vienkartinį kodavimą, į duomenų rinkinį bus pridėti šie trys stulpeliai: ['class_business class', 'class_economy class', 'class_first class'].\n" ] }, { "cell_type": "code", "execution_count": 49, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 235 }, "id": "ZM0eVh0ArKUL", "outputId": "83238a76-b3a5-418d-c0b6-605b02b6891b" }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
IDclass
010business class
120first class
230economy class
340economy class
450economy class
560business class
\n", "
" ], "text/plain": [ " ID class\n", "0 10 business class\n", "1 20 first class\n", "2 30 economy class\n", "3 40 economy class\n", "4 50 economy class\n", "5 60 business class" ] }, "execution_count": 49, "metadata": {}, "output_type": "execute_result" } ], "source": [ "one_hot = pd.DataFrame([\n", " [10,'business class'],\n", " [20,'first class'],\n", " [30, 'economy class'],\n", " [40, 'economy class'],\n", " [50, 'economy class'],\n", " [60, 'business class']\n", "],columns=['ID','class'])\n", "one_hot" ] }, { "cell_type": "markdown", "metadata": { "id": "aVnZ7paDrWmb" }, "source": [ "Atlikime vienos karštosios kodavimo metodą pirmajai stulpeliui\n" ] }, { "cell_type": "code", "execution_count": 50, "metadata": { "id": "RUPxf7egrYKr" }, "outputs": [], "source": [ "one_hot_data = pd.get_dummies(one_hot,columns=['class'])" ] }, { "cell_type": "code", "execution_count": 51, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 235 }, "id": "TM37pHsFr4ge", "outputId": "7be15f53-79b2-447a-979c-822658339a9e" }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
IDclass_business classclass_economy classclass_first class
010100
120001
230010
340010
450010
560100
\n", "
" ], "text/plain": [ " ID class_business class class_economy class class_first class\n", "0 10 1 0 0\n", "1 20 0 0 1\n", "2 30 0 1 0\n", "3 40 0 1 0\n", "4 50 0 1 0\n", "5 60 1 0 0" ] }, "execution_count": 51, "metadata": {}, "output_type": "execute_result" } ], "source": [ "one_hot_data" ] }, { "cell_type": "markdown", "metadata": { "id": "_zXRLOjXujdA" }, "source": [ "Kiekviena vieno karšto kodavimo stulpelis turi 0 arba 1, kurie nurodo, ar ta kategorija egzistuoja tam duomenų taškui.\n" ] }, { "cell_type": "markdown", "metadata": { "id": "bDnC4NQOu0qr" }, "source": [ "Kada naudojame vieno karšto kodavimą? Vieno karšto kodavimas naudojamas vienu ar abiem šiais atvejais:\n", "\n", "1. Kai kategorijų skaičius ir duomenų rinkinio dydis yra mažesni.\n", "2. Kai kategorijos neturi jokios konkrečios tvarkos.\n" ] }, { "cell_type": "markdown", "metadata": { "id": "XnUmci_4uvyu" }, "source": [ "> Pagrindinės mintys: \n", "1. Kodavimas atliekamas siekiant konvertuoti ne skaitinius duomenis į skaitinius. \n", "2. Yra du kodavimo tipai: žymų kodavimas ir vieno karštojo kodavimas, abu gali būti atliekami atsižvelgiant į duomenų rinkinio poreikius. \n" ] }, { "cell_type": "markdown", "metadata": { "id": "K8UXOJYRgRsJ" }, "source": [ "## Pašalinimas pasikartojančių duomenų\n", "\n", "> **Mokymosi tikslas:** Šio poskyrio pabaigoje turėtumėte jaustis užtikrintai atpažindami ir pašalindami pasikartojančias reikšmes iš DataFrame lentelių.\n", "\n", "Be trūkstamų duomenų, realiuose duomenų rinkiniuose dažnai susidursite su pasikartojančiais duomenimis. Laimei, pandas suteikia paprastą būdą aptikti ir pašalinti pasikartojančius įrašus.\n" ] }, { "cell_type": "markdown", "metadata": { "id": "qrEG-Wa0gRsJ" }, "source": [ "### Identifikavimas pasikartojančių reikšmių: `duplicated`\n", "\n", "Pasikartojančias reikšmes galite lengvai nustatyti naudodami pandas metodą `duplicated`, kuris grąžina Boole'o kaukę, nurodančią, ar įrašas `DataFrame` yra ankstesnio įrašo dublikatas. Sukurkime dar vieną pavyzdinį `DataFrame`, kad pamatytume, kaip tai veikia.\n" ] }, { "cell_type": "code", "execution_count": 52, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 204 }, "id": "ZLu6FEnZgRsJ", "outputId": "376512d1-d842-4db1-aea3-71052aeeecaf", "trusted": false }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
lettersnumbers
0A1
1B2
2A1
3B3
4B3
\n", "
" ], "text/plain": [ " letters numbers\n", "0 A 1\n", "1 B 2\n", "2 A 1\n", "3 B 3\n", "4 B 3" ] }, "execution_count": 52, "metadata": {}, "output_type": "execute_result" } ], "source": [ "example6 = pd.DataFrame({'letters': ['A','B'] * 2 + ['B'],\n", " 'numbers': [1, 2, 1, 3, 3]})\n", "example6" ] }, { "cell_type": "code", "execution_count": 53, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "cIduB5oBgRsK", "outputId": "3da27b3d-4d69-4e1d-bb52-0af21bae87f2", "trusted": false }, "outputs": [ { "data": { "text/plain": [ "0 False\n", "1 False\n", "2 True\n", "3 False\n", "4 True\n", "dtype: bool" ] }, "execution_count": 53, "metadata": {}, "output_type": "execute_result" } ], "source": [ "example6.duplicated()" ] }, { "cell_type": "markdown", "metadata": { "id": "0eDRJD4SgRsK" }, "source": [ "### Pašalinimas pasikartojančių reikšmių: `drop_duplicates`\n", "`drop_duplicates` tiesiog grąžina duomenų kopiją, kurioje visos `duplicated` reikšmės yra `False`:\n" ] }, { "cell_type": "code", "execution_count": 54, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 142 }, "id": "w_YPpqIqgRsK", "outputId": "ac66bd2f-8671-4744-87f5-8b8d96553dea", "trusted": false }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
lettersnumbers
0A1
1B2
3B3
\n", "
" ], "text/plain": [ " letters numbers\n", "0 A 1\n", "1 B 2\n", "3 B 3" ] }, "execution_count": 54, "metadata": {}, "output_type": "execute_result" } ], "source": [ "example6.drop_duplicates()" ] }, { "cell_type": "markdown", "metadata": { "id": "69AqoCZAgRsK" }, "source": [ "Tiek `duplicated`, tiek `drop_duplicates` pagal numatytuosius nustatymus atsižvelgia į visas stulpelius, tačiau galite nurodyti, kad jie tikrintų tik tam tikrą jūsų `DataFrame` stulpelių dalį:\n" ] }, { "cell_type": "code", "execution_count": 55, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 111 }, "id": "BILjDs67gRsK", "outputId": "ef6dcc08-db8b-4352-c44e-5aa9e2bec0d3", "trusted": false }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
lettersnumbers
0A1
1B2
\n", "
" ], "text/plain": [ " letters numbers\n", "0 A 1\n", "1 B 2" ] }, "execution_count": 55, "metadata": {}, "output_type": "execute_result" } ], "source": [ "example6.drop_duplicates(['letters'])" ] }, { "cell_type": "markdown", "metadata": { "id": "GvX4og1EgRsL" }, "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n---\n\n**Atsakomybės apribojimas**: \nŠis dokumentas buvo išverstas naudojant AI vertimo paslaugą [Co-op Translator](https://github.com/Azure/co-op-translator). Nors siekiame tikslumo, prašome atkreipti dėmesį, kad automatiniai vertimai gali turėti klaidų ar netikslumų. Originalus dokumentas jo gimtąja kalba turėtų būti laikomas autoritetingu šaltiniu. Kritinei informacijai rekomenduojama profesionali žmogaus vertimo paslauga. Mes neprisiimame atsakomybės už nesusipratimus ar klaidingus interpretavimus, atsiradusius naudojant šį vertimą.\n" ] } ], "metadata": { "anaconda-cloud": {}, "colab": { "name": "notebook.ipynb", "provenance": [] }, "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.5.4" }, "coopTranslator": { "original_hash": "8533b3a2230311943339963fc7f04c21", "translation_date": "2025-09-01T22:11:11+00:00", "source_file": "2-Working-With-Data/08-data-preparation/notebook.ipynb", "language_code": "lt" } }, "nbformat": 4, "nbformat_minor": 0 }