From 113e3fa0494fc90504a45650195612fe98bef91d Mon Sep 17 00:00:00 2001 From: Milagro Teruel Date: Sat, 5 Jun 2021 12:26:03 -0300 Subject: [PATCH] Creado mediante Colaboratory --- Entregable_Parte_2.ipynb | 700 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 700 insertions(+) create mode 100644 Entregable_Parte_2.ipynb diff --git a/Entregable_Parte_2.ipynb b/Entregable_Parte_2.ipynb new file mode 100644 index 0000000..c9e85a1 --- /dev/null +++ b/Entregable_Parte_2.ipynb @@ -0,0 +1,700 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "Entregable Parte 2.ipynb", + "provenance": [], + "collapsed_sections": [], + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "zO4bRoxr2Apy" + }, + "source": [ + "**Diplomatura en Ciencia de Datos, Aprendizaje Automático y sus Aplicaciones**\n", + "\n", + "**Exploración y Curación de Datos**\n", + "\n", + "*Edición 2021*\n", + "\n", + "----\n", + "\n", + "# Trabajo práctico entregable - parte 2\n", + "\n", + "\n", + "En el ejercicio 1 de la parte 1 del entregable seleccionaron las filas y columnas relevantes al problema de predicción de precios de una propiedad. Además de ello, tuvieron que reducir el número de valores posibles para las variables categóricas utilizando información de dominio.\n", + "\n", + "En el ejercicio 2 de la parte 1 del entregable imputaron los valores faltantes de las columnas `Suburb` y las columnas obtenidas a partir del conjunto de datos `airbnb`.\n", + "\n", + "En esta notebook, **se utilizará resultado de dichas operaciones.**\n" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "4udjxjk1EtVU" + }, + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy\n", + "import pandas\n", + "\n", + "import seaborn\n", + "seaborn.set_context('talk')" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 227 + }, + "id": "_qeFN3GnEvMk", + "outputId": "02e6e659-1be0-414f-a6a0-8f8298bb84d7" + }, + "source": [ + "# Acá deberían leer el conjunto de datos que ya tienen.\n", + "melb_df = pandas.read_csv(\n", + " 'https://cs.famaf.unc.edu.ar/~mteruel/datasets/diplodatos/melb_data.csv')\n", + "melb_df[:3]" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
SuburbAddressRoomsTypePriceMethodSellerGDateDistancePostcodeBedroom2BathroomCarLandsizeBuildingAreaYearBuiltCouncilAreaLattitudeLongtitudeRegionnamePropertycount
0Abbotsford85 Turner St2h1480000.0SBiggin3/12/20162.53067.02.01.01.0202.0NaNNaNYarra-37.7996144.9984Northern Metropolitan4019.0
1Abbotsford25 Bloomburg St2h1035000.0SBiggin4/02/20162.53067.02.01.00.0156.079.01900.0Yarra-37.8079144.9934Northern Metropolitan4019.0
2Abbotsford5 Charles St3h1465000.0SPBiggin4/03/20172.53067.03.02.00.0134.0150.01900.0Yarra-37.8093144.9944Northern Metropolitan4019.0
\n", + "
" + ], + "text/plain": [ + " Suburb Address ... Regionname Propertycount\n", + "0 Abbotsford 85 Turner St ... Northern Metropolitan 4019.0\n", + "1 Abbotsford 25 Bloomburg St ... Northern Metropolitan 4019.0\n", + "2 Abbotsford 5 Charles St ... Northern Metropolitan 4019.0\n", + "\n", + "[3 rows x 21 columns]" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 3 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "s-mixICN22kA" + }, + "source": [ + "## Ejercicio 1: Encoding\n", + "\n", + "1. Seleccionar todas las filas y columnas del conjunto de datos obtenido en la parte 1 del entregable, **excepto** `BuildingArea` y `YearBuilt`, que volveremos a imputar más adelante.\n", + "\n", + "2. Aplicar una codificación One-hot encoding a cada fila, tanto para variables numéricas como categóricas. Si lo consideran necesario, pueden volver a reducir el número de categorías únicas.\n", + "\n", + "Algunas opciones:\n", + " 1. Utilizar `OneHotEncoder` junto con el parámetro `categories` para las variables categóricas y luego usar `numpy.hstack` para concatenar el resultado con las variables numéricas. \n", + " 2. `DictVectorizer` con algunos pasos de pre-proceso previo.\n", + "\n", + "Recordar también que el atributo `pandas.DataFrame.values` permite acceder a la matriz de numpy subyacente a un DataFrame.\n" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "K_Qk43aLIl4d" + }, + "source": [ + "categorical_cols = ['Type']\n", + "numerical_cols = ['Rooms']" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "oSNfW1BBJnV0", + "outputId": "10ac472d-62ef-4e9b-f66f-48af6797b3bc" + }, + "source": [ + "melb_df[categorical_cols].nunique()" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "Type 3\n", + "dtype: int64" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 6 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "XPDDOVHNNywn", + "outputId": "4c497064-cca1-4344-b5a1-e8521ecb4cbc" + }, + "source": [ + "# Check for nulls\n", + "melb_df[categorical_cols].isna().sum()" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "Type 0\n", + "dtype: int64" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 7 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ismngxPcfoWb" + }, + "source": [ + "## Ejercicio 2: Imputación por KNN\n", + "\n", + "En el teórico se presentó el método `IterativeImputer` para imputar valores faltantes en variables numéricas. Sin embargo, los ejemplos presentados sólo utilizaban algunas variables numéricas presentes en el conjunto de datos. En este ejercicio, utilizaremos la matriz de datos codificada para imputar datos faltantes de manera más precisa.\n", + "\n", + "1. Agregue a la matriz obtenida en el punto anterior las columnas `YearBuilt` y `BuildingArea`.\n", + "2. Aplique una instancia de `IterativeImputer` con un estimador `KNeighborsRegressor` para imputar los valores de las variables. ¿Es necesario estandarizar o escalar los datos previamente?\n", + "3. Realice un gráfico mostrando la distribución de cada variable antes de ser imputada, y con ambos métodos de imputación." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "G4ClSr_JapCw", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "9468199f-071a-4514-c62b-e161a6113f18" + }, + "source": [ + "from sklearn.experimental import enable_iterative_imputer\n", + "from sklearn.neighbors import KNeighborsRegressor\n", + "from sklearn.impute import IterativeImputer\n", + "\n", + "melb_data_mice = melb_df.copy(deep=True)\n", + "\n", + "mice_imputer = IterativeImputer(random_state=0, estimator=KNeighborsRegressor())\n", + "melb_data_mice[['YearBuilt','BuildingArea']] = mice_imputer.fit_transform(\n", + " melb_data_mice[['YearBuilt', 'BuildingArea']])" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.7/dist-packages/sklearn/impute/_iterative.py:638: ConvergenceWarning: [IterativeImputer] Early stopping criterion not reached.\n", + " \" reached.\", ConvergenceWarning)\n" + ], + "name": "stderr" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ImjXQZUbVoKH" + }, + "source": [ + "Ejemplo de gráfico comparando las distribuciones de datos obtenidas con cada método de imputación." + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 355 + }, + "id": "PMK1ktqYQTJK", + "outputId": "b3ec0023-25cd-41ad-b069-cc59de7c2313" + }, + "source": [ + "mice_year_built = melb_data_mice.YearBuilt.to_frame()\n", + "mice_year_built['Imputation'] = 'KNN over YearBuilt and BuildingArea'\n", + "melb_year_build = melb_df.YearBuilt.dropna().to_frame()\n", + "melb_year_build['Imputation'] = 'Original'\n", + "data = pandas.concat([mice_year_built, melb_year_build])\n", + "fig = plt.figure(figsize=(8, 5))\n", + "g = seaborn.kdeplot(data=data, x='YearBuilt', hue='Imputation')" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "NBN7-5OIxjJW" + }, + "source": [ + "## Ejercicio 3: Reducción de dimensionalidad.\n", + "\n", + "Utilizando la matriz obtenida en el ejercicio anterior:\n", + "1. Aplique `PCA` para obtener $n$ componentes principales de la matriz, donde `n = min(20, X.shape[0])`. ¿Es necesario estandarizar o escalar los datos?\n", + "2. Grafique la varianza capturada por los primeros $n$ componentes principales, para cada $n$.\n", + "3. En base al gráfico, seleccione las primeras $m$ columnas de la matriz transformada para agregar como nuevas características al conjunto de datos." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "WrZTYmG_ZyDy" + }, + "source": [ + "## Ejercicio 4: Composición del resultado\n", + "\n", + "Transformar nuevamente el conjunto de datos procesado en un `pandas.DataFrame` y guardarlo en un archivo.\n", + "\n", + "Para eso, será necesario recordar el nombre original de cada columna de la matriz, en el orden correcto. Tener en cuenta:\n", + "1. El método `OneHotEncoder.get_feature_names` o el atributo `OneHotEncoder.categories_` permiten obtener una lista con los valores de la categoría que le corresponde a cada índice de la matriz.\n", + "2. Ninguno de los métodos aplicados intercambia de lugar las columnas o las filas de la matriz." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "DfchYPgTxvQ4", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 287 + }, + "outputId": "c0bd0b28-1cb8-419c-e799-631045735021" + }, + "source": [ + "## Small example\n", + "from sklearn.decomposition import PCA\n", + "from sklearn.preprocessing import OneHotEncoder\n", + "\n", + "## If we process our data with the following steps:\n", + "categorical_cols = ['Type', 'Regionname']\n", + "numerical_cols = ['Rooms', 'Distance']\n", + "new_columns = []\n", + "\n", + "# Step 1: encode categorical columns\n", + "encoder = OneHotEncoder(handle_unknown='ignore', sparse=False)\n", + "X_cat = encoder.fit_transform(melb_df[categorical_cols])\n", + "for col, col_values in zip(categorical_cols, encoder.categories_):\n", + " for col_value in col_values:\n", + " new_columns.append('{}={}'.format(col, col_value))\n", + "print(\"Matrix has shape {}, with columns: {}\".format(X_cat.shape, new_columns))\n", + "\n", + "# Step 2: Append the numerical columns\n", + "X = numpy.hstack([X_cat, melb_df[numerical_cols].values])\n", + "new_columns.extend(numerical_cols)\n", + "print(\"Matrix has shape {}, with columns: {}\".format(X_cat.shape, new_columns))\n", + "\n", + "# Step 3: Append some new features, like PCA\n", + "pca = PCA(n_components=2)\n", + "pca_dummy_features = pca.fit_transform(X)\n", + "X_pca = numpy.hstack([X, pca_dummy_features])\n", + "new_columns.extend(['pca1', 'pca2'])\n", + "\n", + "## Re-build dataframe\n", + "processed_melb_df = pandas.DataFrame(data=X_pca, columns=new_columns)\n", + "processed_melb_df.head()" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Matrix has shape (13580, 11), with columns: ['Type=h', 'Type=t', 'Type=u', 'Regionname=Eastern Metropolitan', 'Regionname=Eastern Victoria', 'Regionname=Northern Metropolitan', 'Regionname=Northern Victoria', 'Regionname=South-Eastern Metropolitan', 'Regionname=Southern Metropolitan', 'Regionname=Western Metropolitan', 'Regionname=Western Victoria']\n", + "Matrix has shape (13580, 11), with columns: ['Type=h', 'Type=t', 'Type=u', 'Regionname=Eastern Metropolitan', 'Regionname=Eastern Victoria', 'Regionname=Northern Metropolitan', 'Regionname=Northern Victoria', 'Regionname=South-Eastern Metropolitan', 'Regionname=Southern Metropolitan', 'Regionname=Western Metropolitan', 'Regionname=Western Victoria', 'Rooms', 'Distance']\n" + ], + "name": "stdout" + }, + { + "output_type": "execute_result", + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Type=hType=tType=uRegionname=Eastern MetropolitanRegionname=Eastern VictoriaRegionname=Northern MetropolitanRegionname=Northern VictoriaRegionname=South-Eastern MetropolitanRegionname=Southern MetropolitanRegionname=Western MetropolitanRegionname=Western VictoriaRoomsDistancepca1pca2
01.00.00.00.00.01.00.00.00.00.00.02.02.5-7.669418-0.292703
11.00.00.00.00.01.00.00.00.00.00.02.02.5-7.669418-0.292703
21.00.00.00.00.01.00.00.00.00.00.03.02.5-7.6202010.619633
31.00.00.00.00.01.00.00.00.00.00.03.02.5-7.6202010.619633
41.00.00.00.00.01.00.00.00.00.00.04.02.5-7.5709841.531969
\n", + "
" + ], + "text/plain": [ + " Type=h Type=t Type=u ... Distance pca1 pca2\n", + "0 1.0 0.0 0.0 ... 2.5 -7.669418 -0.292703\n", + "1 1.0 0.0 0.0 ... 2.5 -7.669418 -0.292703\n", + "2 1.0 0.0 0.0 ... 2.5 -7.620201 0.619633\n", + "3 1.0 0.0 0.0 ... 2.5 -7.620201 0.619633\n", + "4 1.0 0.0 0.0 ... 2.5 -7.570984 1.531969\n", + "\n", + "[5 rows x 15 columns]" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 147 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "mVBLFc8PhRtW" + }, + "source": [ + "## Ejercicio 5: Documentación\n", + "\n", + "En un documento `.pdf` o `.md` realizar un reporte de las operaciones que realizaron para obtener el conjunto de datos final. Se debe incluir:\n", + " 1. Criterios de exclusión (o inclusión) de filas\n", + " 2. Interpretación de las columnas presentes\n", + " 2. Todas las transofrmaciones realizadas\n", + "\n", + "Este documento es de uso técnico exclusivamente, y su objetivo es permitir que otres desarrolladores puedan reproducir los mismos pasos y obtener el mismo resultado. Debe ser detallado pero consiso. Por ejemplo:\n", + "\n", + "```\n", + " ## Criterios de exclusión de ejemplos\n", + " 1. Se eliminan ejemplos donde el año de construcción es previo a 1900\n", + "\n", + " ## Características seleccionadas\n", + " ### Características categóricas\n", + " 1. Type: tipo de propiedad. 3 valores posibles\n", + " 2. ...\n", + " Todas las características categóricas fueron codificadas con un\n", + " método OneHotEncoding utilizando como máximo sus 30 valores más \n", + " frecuentes.\n", + " \n", + " ### Características numéricas\n", + " 1. Rooms: Cantidad de habitaciones\n", + " 2. Distance: Distancia al centro de la ciudad.\n", + " 3. airbnb_mean_price: Se agrega el precio promedio diario de \n", + " publicaciones de la plataforma AirBnB en el mismo código \n", + " postal. [Link al repositorio con datos externos].\n", + "\n", + " ### Transformaciones:\n", + " 1. Todas las características numéricas fueron estandarizadas.\n", + " 2. La columna `Suburb` fue imputada utilizando el método ...\n", + " 3. Las columnas `YearBuilt` y ... fueron imputadas utilizando el \n", + " algoritmo ...\n", + " 4. ...\n", + "\n", + " ### Datos aumentados\n", + " 1. Se agregan las 5 primeras columnas obtenidas a través del\n", + " método de PCA, aplicado sobre el conjunto de datos\n", + " totalmente procesado.\n", + "```\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Bq7nuPg2HIYx" + }, + "source": [ + "" + ] + } + ] +} \ No newline at end of file