From 9da8e13c9237ff4252ce1cd5aea56f8851e22fba Mon Sep 17 00:00:00 2001 From: Caitlyn Chen Date: Fri, 12 Feb 2021 22:37:18 -0800 Subject: [PATCH] rm examples --- examples 14-05-28-947/similarity.ipynb | 444 ------------------------- 1 file changed, 444 deletions(-) delete mode 100644 examples 14-05-28-947/similarity.ipynb diff --git a/examples 14-05-28-947/similarity.ipynb b/examples 14-05-28-947/similarity.ipynb deleted file mode 100644 index a1f8397f..00000000 --- a/examples 14-05-28-947/similarity.ipynb +++ /dev/null @@ -1,444 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 42, - "metadata": {}, - "outputs": [], - "source": [ - "import pandas as pd\n", - "import lux\n", - "from lux.vis.Clause import Clause\n", - "from lux.utils.utils import get_filter_specs\n", - "import matplotlib.pyplot as plt\n", - "import matplotlib\n", - "\n", - "lux.config.default_display = \"lux\"\n", - "lux.config.plotting_backend = \"matplotlib\"\n", - "\n", - "# def change_color_make_transparent_add_title(fig, ax):\n", - "# # fig.set_figwidth(7)\n", - "# ax.set_title(\"Custom Title\")\n", - "# return fig, ax\n", - "# lux.config.plotting_style = change_color_make_transparent_add_title\n", - "# plt.rcParams['axes.prop_cycle'] = matplotlib.cycler(color='g')\n", - "# def changeOpacityScatterOnly(fig, ax):\n", - "# ax = ax.set_alpha(0)\n", - "# return fig, ax\n", - "# if chart.mark=='circle':\n", - "# chart = chart.configure_mark(opacity=0.1) # lower opacity\n", - "# return chart\n", - "# lux.config.plotting_style = changeOpacityScatterOnly" - ] - }, - { - "cell_type": "code", - "execution_count": 44, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/caitlynachen/Desktop/frontendlux/tutorial-env/lib/python3.8/site-packages/lux_api-0.2.2-py3.8.egg/lux/executor/PandasExecutor.py:396: UserWarning:\n", - "Lux detects that the attribute 'Year' may be temporal.\n", - "To display visualizations for these attributes accurately, please convert temporal attributes to Pandas Datetime objects using the pd.to_datetime function and provide a 'format' parameter to specify the datetime format of the attribute.\n", - "For example, you can convert a year-only attribute (e.g., 1998, 1971, 1982) to Datetime type by specifying the `format` as '%Y'.\n", - "\n", - "Here is a starter template that you can use for converting the temporal fields:\n", - "\tdf['Year'] = pd.to_datetime(df['Year'], format='')\n", - "\n", - "See more at: https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.to_datetime.html\n", - "If Year is not a temporal attribute, please use override Lux's automatically detected type:\n", - "\tdf.set_data_type({'Year':'quantitative'})\n" - ] - }, - { - "data": { - "text/plain": [ - "'import matplotlib.pyplot as plt\\nplt.rcParams.update(\\n {\\n \"axes.titlesize\": 20,\\n \"axes.titleweight\": \"bold\",\\n \"axes.labelweight\": \"bold\",\\n \"axes.labelsize\": 16,\\n \"legend.fontsize\": 14,\\n \"legend.title_fontsize\": 15,\\n \"xtick.labelsize\": 13,\\n \"ytick.labelsize\": 13,\\n }\\n )\\nimport numpy as np\\nfrom math import nan\\ndf = pd.DataFrame({\\' \\': {0: 55.2, 1: 73.6, 2: 92.0, 3: 110.39999999999999, 4: 128.8, 5: 147.2, 6: 165.59999999999997, 7: 184.0, 8: 202.39999999999998, 9: 220.8}, \\'Number of Records\\': {0: 27.0, 1: 95.0, 2: 120.0, 3: 44.0, 4: 19.0, 5: 47.0, 6: 13.0, 7: 14.0, 8: 5.0, 9: 8.0}})\\nfig, ax = plt.subplots()\\nbars = df[\\' \\']\\nmeasurements = df[\\'Number of Records\\']\\nax.bar(bars, measurements, width=15.333333333333334)\\nax.set_xlabel(\\'Series (binned)\\')\\nax.set_ylabel(\\'Number of Records\\')\\n\\nfig'" - ] - }, - "execution_count": 44, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# df = pd.read_csv(\"https://raw.githubusercontent.com/lux-org/lux-datasets/master/data/employee.csv\")\n", - "df = pd.read_csv(\"../lux/data/car.csv\")\n", - "\n", - "# a = df[\"YearsAtCompany\"]/df[\"TotalWorkingYears\"]\n", - "df = df.rename(columns={\"Horsepower\": \" \"})\n", - "df.recommendation[\"Distribution\"][0].to_matplotlib_code()\n", - "# a[\"Distribution\"]\n", - "# df._repr_html_()" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "d60fac313ea44b88b1887c1245a76f12", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Button(description='Toggle Pandas/Lux', layout=Layout(top='5px', width='140px'), style=ButtonStyle())" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "6b9feebd1ef44f5a91fd1f4540bd6bfd", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Output()" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df = pd.read_csv(\"../lux/data/car.csv\")\n", - "df[\"Year\"] = pd.to_datetime(df[\"Year\"], format='%Y') # change pandas dtype for the column \"Year\" to datetype\n", - "\n", - "# df.set_intent([lux.Clause(\"Displacement\",channel=\"x\")])\n", - "# lux.Clause(\"Origin\",channel=\"y\")])\n", - "# df.set_intent([lux.Clause(\"Displacement\",channel=\"x\"), \n", - "# lux.Clause(\"Acceleration\", channel=\"y\"), \n", - "# lux.Clause(\"Origin\")])\n", - "\n", - "# df.current_vis[0].mark\n", - "# len(get_filter_specs(df.intent))\n", - "df" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "df = pd.read_csv(\"https://github.com/chiphuyen/just-pandas-things/blob/master/data/interviews.csv?raw=True\")\n", - "df['Date'] = pd.to_datetime(df['Date'], format='%b %d, %Y')\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# df = pd.read_csv(\"https://raw.githubusercontent.com/lux-org/lux-datasets/master/data/airbnb_nyc.csv\")\n", - "# df['last_review'] = pd.to_datetime(df['last_review'], format='%Y-%m-%d')\n", - "\n", - "# df.set_intent([lux.Clause(\"price\",channel=\"x\"), \n", - "# lux.Clause(\"availability_365\",channel=\"y\"), \n", - "# lux.Clause(\"longitude\")])\n", - "df" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "lux.config.plotting_backend = \"vegalite\"\n", - "\n", - "df = pd.read_csv(\"../lux/data/car.csv\")\n", - "df[\"Year\"] = pd.to_datetime(df[\"Year\"], format='%Y') # change pandas dtype for the column \"Year\" to datetype\n", - "\n", - "df.set_intent([lux.Clause(\"Displacement\",channel=\"x\")])\n", - "# lux.Clause(\"Origin\",channel=\"y\")])\n", - "# df.set_intent([lux.Clause(\"Displacement\",channel=\"x\"), \n", - "# lux.Clause(\"Acceleration\", channel=\"y\"), \n", - "# lux.Clause(\"Origin\")])\n", - "\n", - "# df.current_vis[0].mark\n", - "# len(get_filter_specs(df.intent))\n", - "df" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "vis = df.exported[0]" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "plt.rcParams.update(\n", - " {\n", - " \"axes.titlesize\": 20,\n", - " \"axes.titleweight\": \"bold\",\n", - " \"axes.labelweight\": \"bold\",\n", - " \"axes.labelsize\": 16,\n", - " \"legend.fontsize\": 14,\n", - " \"legend.title_fontsize\": 15,\n", - " # \"font.family\": \"DejaVu Sans\",\n", - " \"xtick.labelsize\": 13,\n", - " \"ytick.labelsize\": 13,\n", - " }\n", - " )\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "from math import nan\n", - "from matplotlib.cm import ScalarMappable\n", - "fig, ax = plt.subplots()\n", - "x_pts = df['Displacement']\n", - "y_pts = df['Weight']\n", - "ax.scatter(x_pts, y_pts, alpha=0.5)\n", - "ax.set_xlabel('Displacement')\n", - "ax.set_ylabel('Weight')\n", - "ax.set_title(\"Custom Title\")\n", - "fig\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "d619043b586d4818bafcea2e80eba696", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "LuxWidget(current_vis={'config': 'iVBORw0KGgoAAAANSUhEUgAAAUQAAAEgCAYAAADMjwqKAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "print(vis.to_matplotlib_code())\n", - "vis" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "plt.rcParams.update(\n", - " {\n", - " \"axes.titlesize\": 20,\n", - " \"axes.titleweight\": \"bold\",\n", - " \"axes.labelweight\": \"bold\",\n", - " \"axes.labelsize\": 16,\n", - " \"legend.fontsize\": 14,\n", - " \"legend.title_fontsize\": 15,\n", - " # \"font.family\": \"DejaVu Sans\",\n", - " \"xtick.labelsize\": 13,\n", - " \"ytick.labelsize\": 13,\n", - " }\n", - " )\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "from math import nan\n", - "from matplotlib.cm import ScalarMappable\n", - "fig, ax = plt.subplots()\n", - "x_pts = df['Weight']\n", - "y_pts = df['Displacement']\n", - "ax.scatter(x_pts, y_pts, alpha=0.5)\n", - "ax.set_xlabel('Weight')\n", - "ax.set_ylabel('Displacement')\n", - "ax.set_title(\"Custom Title\")\n", - "fig" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "df.recommendation['Occurrence'][0].to_Altair()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "import altair as alt\n", - "visData = pd.DataFrame({'Origin': {0: 'Europe', 1: 'Japan', 2: 'USA'}, 'Record': {0: 68, 1: 79, 2: 245}})\\n\\nchart = alt.Chart(visData).mark_bar().encode(\n", - " y = alt.Y('Origin', type= 'nominal', axis=alt.Axis(labelOverlap=True, title='Origin')),\\n x = alt.X('Record', type= 'quantitative', title='Number of Records', axis=alt.Axis(title='Number of Records')),\\n)\\nchart = chart.configure_mark(tooltip=alt.TooltipContent('encoding'))\\nchart = chart.configure_title(fontWeight=500,fontSize=13,font='Helvetica Neue')\\nchart = chart.configure_axis(titleFontWeight=500,titleFontSize=11,titleFont='Helvetica Neue',\\n\\t\\t\\tlabelFontWeight=400,labelFontSize=8,labelFont='Helvetica Neue',labelColor='#505050')\\nchart = chart.configure_legend(titleFontWeight=500,titleFontSize=10,titleFont='Helvetica Neue',\\n\\t\\t\\tlabelFontWeight=400,labelFontSize=8,labelFont='Helvetica Neue')\\nchart = chart.properties(width=160,height=150)\\n\\nchart" - ] - }, - { - "cell_type": "raw", - "metadata": {}, - "source": [ - "from lux.vis.Vis import Vis\n", - "\n", - "dataset = [\n", - " {\"normal\": \"USA\", \"long_var\": 3},\n", - " {\"normal\": \"Europe\", \"long_var\": 3},\n", - " {\"normal\": \"USA\", \"long_var\": 2},\n", - " {\"normal\": \"Europe\", \"long_var\": 4},\n", - " ]\n", - "test = pd.DataFrame(dataset)\n", - "vis = Vis([\"long_var\", \"normal\"], test)\n", - "vis" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "one_current_vis = lambda ldf: ldf.current_vis is not None and len(ldf.current_vis) == 1" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "df = pd.read_csv(\"../lux/data/car.csv\")\n", - "df[\"Year\"] = pd.to_datetime(df[\"Year\"], format='%Y') # change pandas dtype for the column \"Year\" to datetype\n", - "# df[\"Month\"] = pd.to_datetime(df[\"Month\"], format='%M') # change pandas dtype for the column \"Year\" to datetype\n", - "\n", - "df.set_intent([lux.Clause(\"Year\",channel=\"x\"), \n", - " lux.Clause(\"Displacement\",channel=\"y\"), \n", - " lux.Clause(\"Origin=USA\")])\n", - "# last = get_filter_specs(df.intent)[-1]\n", - "# query = df.intent.copy()[0:-1]\n", - "# # array of possible values for attribute\n", - "# arr = df[last.attribute].unique().tolist()\n", - "# query.append(lux.Clause(last.attribute, last.attribute, arr))\n", - "# query_vc = VisList(query,df) \n", - "# query_vc\n", - "\n", - "# search_space_vc = VisList(df.current_vis,df)\n", - " \n", - "# preprocess(query_vis)\n", - "# #for loop to create assign euclidean distance\n", - "# recommendation = {\"action\":\"Similarity\",\n", - "# \"description\":\"Show other charts that are visually similar to the Current vis.\"}\n", - "# for vis in search_space_vc:\n", - "# preprocess(vis)\n", - "# vis.score = euclidean_dist(query_vis, vis)\n", - "# search_space_vc.normalize_score(invert_order=True)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "lux.register_action(\"similarity\", similar_pattern, one_current_vis)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "df" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "df.current_vis" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "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.8.2" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -}