</br>\n# #### Supervised learning\n# - If x is input and y is output\n# - The algorithm is used to learn the mapping function, of input to output \n# \n# <img src=\"pics/supervised_learning.png\">\n#\n# - Using the training dataset, the algorithm can train and learn:\n# - What is typically a face\n# - What is typically a non-face\n# \n# - Once the training is done, the model is given an input, and the output is tested\n# - For this example the user can distinguish whether the answer is correct, as the test \n#\n# <br></br>\n# #### Unsupervised learning\n# - The training of data that is not classified or labelled \n#\n# <img src=\"pics/unsupervised_learning.png\">\n#\n# - Can be used to cluster the data into classes\n# - Or by a chosen variable, e.g color or shape (for the given example)\n#\n# <br></br>\n# #### Reinforcement learning\n# - Learning by interacting with a space or an environment\n# - Selects an action based on the past experience, exploration and new choices\n#\n# <img src=\"pics/reinforcement_learning.png\">\n#\n# - Can use a previously tranined model/algorithm to train for identifing a similar criteria\n\n#\n"},"script_size":{"kind":"number","value":3725,"string":"3,725"}}},{"rowIdx":75,"cells":{"path":{"kind":"string","value":"/Week7/week_7.ipynb"},"content_id":{"kind":"string","value":"fd1381d66161c56d24283f370a1f94f35200ba10"},"detected_licenses":{"kind":"list like","value":[],"string":"[]","isConversational":false},"license_type":{"kind":"string","value":"no_license"},"repo_name":{"kind":"string","value":"Devsaa05/Inter_2-incubitu"},"repo_url":{"kind":"string","value":"https://github.com/Devsaa05/Inter_2-incubitu"},"star_events_count":{"kind":"number","value":1,"string":"1"},"fork_events_count":{"kind":"number","value":0,"string":"0"},"gha_license_id":{"kind":"null"},"gha_event_created_at":{"kind":"timestamp","value":"2020-07-31T12:32:59","string":"2020-07-31T12:32:59"},"gha_updated_at":{"kind":"timestamp","value":"2020-07-31T12:32:44","string":"2020-07-31T12:32:44"},"gha_language":{"kind":"string","value":"Jupyter Notebook"},"language":{"kind":"string","value":"Jupyter Notebook"},"is_generated":{"kind":"bool","value":false,"string":"false"},"is_vendor":{"kind":"bool","value":false,"string":"false"},"conversion_extension":{"kind":"string","value":".py"},"size":{"kind":"number","value":117856,"string":"117,856"},"script":{"kind":"string","value":"# ---\n# jupyter:\n# jupytext:\n# text_representation:\n# extension: .py\n# format_name: light\n# format_version: '1.5'\n# jupytext_version: 1.15.2\n# kernelspec:\n# display_name: Python 3\n# language: python\n# name: python3\n# ---\n\n#https://rightcode.co.jp/blog/information-technology/pytorch-mnist-learning\nimport torch.nn.functional as f\nfrom torch.utils.data import DataLoader\nfrom torchvision import datasets, transforms\nimport matplotlib.pyplot as plt\n\n\nclass MyNet(torch.nn.Module):\n def __init__(self):\n super(MyNet, self).__init__()\n self.fc1 = torch.nn.Linear(28*28, 1000)\n self.fc2 = torch.nn.Linear(1000, 10)\n \n def forward(self, x):\n x = self.fc1(x)\n x = torch.sigmoid(x)\n x = self.fc2(x)\n \n return f.log_softmax(x, dim=1)\n\n\ndef load_MNIST(batch=128, intensity=1.0):\n train_loader = torch.utils.data.DataLoader(\n datasets.MNIST('./data',\n train=True,\n download=True,\n transform=transforms.Compose([\n transforms.ToTensor(),\n transforms.Lambda(lambda x: x * intensity)\n ])),\n batch_size=batch,\n shuffle=True)\n \n test_loader = torch.utils.data.DataLoader(\n datasets.MNIST('./data',\n train=False,\n transform=transforms.Compose([\n transforms.ToTensor(),\n transforms.Lambda(lambda x: x * intensity)\n ])),\n batch_size=batch,\n shuffle=True)\n \n return {'train': train_loader, 'test': test_loader}\n\n\n# +\nnum_epoch = 20\nhistory = {\n 'train_lostt':[],\n 'test_lostt':[],\n 'test_acc':[]\n}\n\ndevice = 'cuda' if torch.cuda.is_available() else 'cpu'\nnet = MyNet().to(device)\nloaders = load_MNIST()\n\n# -\n\noptimizer = torch.optim.Adam(params=net.parameters(), lr=0.001)\n\n# +\nfor i_epoch in range(num_epoch):\n loss = None\n \n net.train(True)\n \n for i, (data, target) in enumerate(loaders['train']):\n data = data.view(-1, 28*28)\n data = data.to(device)\n target = target.to(device)\n \n optimizer.zero_grad()\n output = net(data)\n loss = f.nll_loss(output, target)\n loss.backward()\n optimizer.step()\n \n if i % 10 == 0:\n print('Training log: {} epoch ({} / 60000 train. data). Loss: {}'.format(i_epoch+1, (i+1)*128, loss.item()))\n \n history['train_loss'].append(loss)\n \n net.eval()\n test_loss = 0\n correct = 0\n \n with torch.no_grad():\n for data, target in loaders['test']:\n data = data.view(-1, 28*28)\n data = data.to(device)\n target = target.to(device)\n \n output = net(data)\n test_loss += f.nll_loss(output, target, reduction='sum').item()\n pred = output.argmax(dim=1, keepdim=True)\n correct += pred.eq(target.view_as(pred)).sum().item()\n \n test_loss /= 10000\n print('Test loss (avg): {}, Accuracy: {}'.format(test_loss, correct / 10000))\n \n history['test_loss'].append(test_loss)\n history['test_acc'].append(correct / 10000)\n \nprint(history)\nplt.figure()\nplt.plot(range(1, num_epoch+1), history['train_loss'], label='train_loss')\nplt.plot(range(1, num_epoch+1), history['test_loss'], label='test_loss')\nplt.xlabel('epoch')\nplt.legend()\nplt.savefig('loss.png')\n\nplt.figure()\nplt.plot(range(1, epoch+1), history['test_acc'])\nplt.title('test accuracy')\nplt.xlabel('epoch')\nplt.savefig('test_acc.png')\n \n# -\n\nprint(torch.cuda.is_available())\n\ntorch.cuda.get_device_name(0)\n\n\n index labels:\n\nweights = {\"alice\": 68, \"bob\": 83, \"colin\": 86, \"darwin\": 68}\ns3 = pd.Series(weights)\ns3\n\n# You can control which elements you want to include in the `Series` and in what order by explicitly specifying the desired `index`:\n\ns4 = pd.Series(weights, index = [\"colin\", \"alice\"])\ns4\n\n# ## Automatic alignment\n# When an operation involves multiple `Series` objects, `pandas` automatically aligns items by matching index labels.\n\n# +\nprint(s2.keys())\nprint(s3.keys())\n\ns2 + s3\n# -\n\n# The resulting `Series` contains the union of index labels from `s2` and `s3`. Since `\"colin\"` is missing from `s2` and `\"charles\"` is missing from `s3`, these items have a `NaN` result value. (ie. Not-a-Number means *missing*).\n#\n# Automatic alignment is very handy when working with data that may come from various sources with varying structure and missing items. But if you forget to set the right index labels, you can have surprising results:\n\n# +\ns5 = pd.Series([1000,1000,1000,1000])\nprint(\"s2 =\", s2.values)\nprint(\"s5 =\", s5.values)\n\ns2 + s5\n# -\n\n# Pandas could not align the `Series`, since their labels do not match at all, hence the full `NaN` result.\n\n# ## Init with a scalar\n# You can also initialize a `Series` object using a scalar and a list of index labels: all items will be set to the scalar.\n\nmeaning = pd.Series(42, [\"life\", \"universe\", \"everything\"])\nmeaning\n\n# ## `Series` name\n# A `Series` can have a `name`:\n\ns6 = pd.Series([83, 68], index=[\"bob\", \"alice\"], name=\"weights\")\ns6\n\n# ## Plotting a `Series`\n# Pandas makes it easy to plot `Series` data using matplotlib (for more details on matplotlib, check out the [matplotlib tutorial](tools_matplotlib.ipynb)). Just import matplotlib and call the `plot()` method:\n\n# %matplotlib inline\nimport matplotlib.pyplot as plt\ntemperatures = [4.4,5.1,6.1,6.2,6.1,6.1,5.7,5.2,4.7,4.1,3.9,3.5]\ns7 = pd.Series(temperatures, name=\"Temperature\")\ns7.plot()\nplt.show()\n\n# There are *many* options for plotting your data. It is not necessary to list them all here: if you need a particular type of plot (histograms, pie charts, etc.), just look for it in the excellent [Visualization](http://pandas.pydata.org/pandas-docs/stable/visualization.html) section of pandas' documentation, and look at the example code.\n\n# # Handling time\n# Many datasets have timestamps, and pandas is awesome at manipulating such data:\n# * it can represent periods (such as 2016Q3) and frequencies (such as \"monthly\"),\n# * it can convert periods to actual timestamps, and *vice versa*,\n# * it can resample data and aggregate values any way you like,\n# * it can handle timezones.\n#\n# ## Time range\n# Let's start by creating a time series using `pd.date_range()`. This returns a `DatetimeIndex` containing one datetime per hour for 12 hours starting on October 29th 2016 at 5:30pm.\n\ndates = pd.date_range('2016/10/29 5:30pm', periods=12, freq='H')\ndates\n\n# This `DatetimeIndex` may be used as an index in a `Series`:\n\ntemp_series = pd.Series(temperatures, dates)\ntemp_series\n\n# Let's plot this series:\n\n# +\ntemp_series.plot(kind=\"bar\")\n\nplt.grid(True)\nplt.show()\n# -\n\n# ## Resampling\n# Pandas lets us resample a time series very simply. Just call the `resample()` method and specify a new frequency:\n\ntemp_series_freq_2H = temp_series.resample(\"2H\")\ntemp_series_freq_2H\n\n# The resampling operation is actually a deferred operation, which is why we did not get a `Series` object, but a `DatetimeIndexResampler` object instead. To actually perform the resampling operation, we can simply call the `mean()` method: Pandas will compute the mean of every pair of consecutive hours:\n\ntemp_series_freq_2H = temp_series_freq_2H.mean()\n\n# Let's plot the result:\n\ntemp_series_freq_2H.plot(kind=\"bar\")\nplt.show()\n\n# Note how the values have automatically been aggregated into 2-hour periods. If we look at the 6-8pm period, for example, we had a value of `5.1` at 6:30pm, and `6.1` at 7:30pm. After resampling, we just have one value of `5.6`, which is the mean of `5.1` and `6.1`. Rather than computing the mean, we could have used any other aggregation function, for example we can decide to keep the minimum value of each period:\n\ntemp_series_freq_2H = temp_series.resample(\"2H\").min()\ntemp_series_freq_2H\n\n# Or, equivalently, we could use the `apply()` method instead:\n\ntemp_series_freq_2H = temp_series.resample(\"2H\").apply(np.min)\ntemp_series_freq_2H\n\n# ## Upsampling and interpolation\n# This was an example of downsampling. We can also upsample (ie. increase the frequency), but this creates holes in our data:\n\ntemp_series_freq_15min = temp_series.resample(\"15Min\").mean()\ntemp_series_freq_15min.head(n=10) # `head` displays the top n values\n\n# One solution is to fill the gaps by interpolating. We just call the `interpolate()` method. The default is to use linear interpolation, but we can also select another method, such as cubic interpolation:\n\ntemp_series_freq_15min = temp_series.resample(\"15Min\").interpolate(method=\"cubic\")\ntemp_series_freq_15min.head(n=10)\n\ntemp_series.plot(label=\"Period: 1 hour\")\ntemp_series_freq_15min.plot(label=\"Period: 15 minutes\")\nplt.legend()\nplt.show()\n\n# ## Timezones\n# By default datetimes are *naive*: they are not aware of timezones, so 2016-10-30 02:30 might mean October 30th 2016 at 2:30am in Paris or in New York. We can make datetimes timezone *aware* by calling the `tz_localize()` method:\n\ntemp_series_ny = temp_series.tz_localize(\"America/New_York\")\ntemp_series_ny\n\n# Note that `-04:00` is now appended to all the datetimes. This means that these datetimes refer to [UTC](https://en.wikipedia.org/wiki/Coordinated_Universal_Time) - 4 hours.\n#\n# We can convert these datetimes to Paris time like this:\n\ntemp_series_paris = temp_series_ny.tz_convert(\"Europe/Paris\")\ntemp_series_paris\n\n# You may have noticed that the UTC offset changes from `+02:00` to `+01:00`: this is because France switches to winter time at 3am that particular night (time goes back to 2am). Notice that 2:30am occurs twice! Let's go back to a naive representation (if you log some data hourly using local time, without storing the timezone, you might get something like this):\n\ntemp_series_paris_naive = temp_series_paris.tz_localize(None)\ntemp_series_paris_naive\n\n# Now `02:30` is really ambiguous. If we try to localize these naive datetimes to the Paris timezone, we get an error:\n\ntry:\n temp_series_paris_naive.tz_localize(\"Europe/Paris\")\nexcept Exception as e:\n print(type(e))\n print(e)\n\n# Fortunately using the `ambiguous` argument we can tell pandas to infer the right DST (Daylight Saving Time) based on the order of the ambiguous timestamps:\n\ntemp_series_paris_naive.tz_localize(\"Europe/Paris\", ambiguous=\"infer\")\n\n# ## Periods\n# The `pd.period_range()` function returns a `PeriodIndex` instead of a `DatetimeIndex`. For example, let's get all quarters in 2016 and 2017:\n\nquarters = pd.period_range('2016Q1', periods=8, freq='Q')\nquarters\n\n# Adding a number `N` to a `PeriodIndex` shifts the periods by `N` times the `PeriodIndex`'s frequency:\n\nquarters + 3\n\n# The `asfreq()` method lets us change the frequency of the `PeriodIndex`. All periods are lengthened or shortened accordingly. For example, let's convert all the quarterly periods to monthly periods (zooming in):\n\nquarters.asfreq(\"M\")\n\n# By default, the `asfreq` zooms on the end of each period. We can tell it to zoom on the start of each period instead:\n\nquarters.asfreq(\"M\", how=\"start\")\n\n# And we can zoom out:\n\nquarters.asfreq(\"A\")\n\n# Of course we can create a `Series` with a `PeriodIndex`:\n\nquarterly_revenue = pd.Series([300, 320, 290, 390, 320, 360, 310, 410], index = quarters)\nquarterly_revenue\n\nquarterly_revenue.plot(kind=\"line\")\nplt.show()\n\n# We can convert periods to timestamps by calling `to_timestamp`. By default this will give us the first day of each period, but by setting `how` and `freq`, we can get the last hour of each period:\n\nlast_hours = quarterly_revenue.to_timestamp(how=\"end\", freq=\"H\")\nlast_hours\n\n# And back to periods by calling `to_period`:\n\nlast_hours.to_period()\n\n# Pandas also provides many other time-related functions that we recommend you check out in the [documentation](http://pandas.pydata.org/pandas-docs/stable/timeseries.html). To whet your appetite, here is one way to get the last business day of each month in 2016, at 9am:\n\nmonths_2016 = pd.period_range(\"2016\", periods=12, freq=\"M\")\none_day_after_last_days = months_2016.asfreq(\"D\") + 1\nlast_bdays = one_day_after_last_days.to_timestamp() - pd.tseries.offsets.BDay()\nlast_bdays.to_period(\"H\") + 9\n\n# # `DataFrame` objects\n# A DataFrame object represents a spreadsheet, with cell values, column names and row index labels. You can define expressions to compute columns based on other columns, create pivot-tables, group rows, draw graphs, etc. You can see `DataFrame`s as dictionaries of `Series`.\n#\n# ## Creating a `DataFrame`\n# You can create a DataFrame by passing a dictionary of `Series` objects:\n\npeople_dict = {\n \"weight\": pd.Series([68, 83, 112], index=[\"alice\", \"bob\", \"charles\"]),\n \"birthyear\": pd.Series([1984, 1985, 1992], index=[\"bob\", \"alice\", \"charles\"], name=\"year\"),\n \"children\": pd.Series([0, 3], index=[\"charles\", \"bob\"]),\n \"hobby\": pd.Series([\"Biking\", \"Dancing\"], index=[\"alice\", \"bob\"]),\n}\npeople = pd.DataFrame(people_dict)\npeople\n\n# A few things to note:\n# * the `Series` were automatically aligned based on their index,\n# * missing values are represented as `NaN`,\n# * `Series` names are ignored (the name `\"year\"` was dropped),\n# * `DataFrame`s are displayed nicely in Jupyter notebooks, woohoo!\n\n# You can access columns pretty much as you would expect. They are returned as `Series` objects:\n\npeople[\"birthyear\"]\n\n# You can also get multiple columns at once:\n\npeople[[\"birthyear\", \"hobby\"]]\n\n# If you pass a list of columns and/or index row labels to the `DataFrame` constructor, it will guarantee that these columns and/or rows will exist, in that order, and no other column/row will exist. For example:\n\nd2 = pd.DataFrame(\n people_dict,\n columns=[\"birthyear\", \"weight\", \"height\"],\n index=[\"bob\", \"alice\", \"eugene\"]\n )\nd2\n\n# Another convenient way to create a `DataFrame` is to pass all the values to the constructor as an `ndarray`, or a list of lists, and specify the column names and row index labels separately:\n\nvalues = [\n [1985, np.nan, \"Biking\", 68],\n [1984, 3, \"Dancing\", 83],\n [1992, 0, np.nan, 112]\n ]\nd3 = pd.DataFrame(\n values,\n columns=[\"birthyear\", \"children\", \"hobby\", \"weight\"],\n index=[\"alice\", \"bob\", \"charles\"]\n )\nd3\n\n# To specify missing values, you can either use `np.nan` or NumPy's masked arrays:\n\nmasked_array = np.ma.asarray(values, dtype=np.object)\nmasked_array[(0, 2), (1, 2)] = np.ma.masked\nd3 = pd.DataFrame(\n masked_array,\n columns=[\"birthyear\", \"children\", \"hobby\", \"weight\"],\n index=[\"alice\", \"bob\", \"charles\"]\n )\nd3\n\n# Instead of an `ndarray`, you can also pass a `DataFrame` object:\n\nd4 = pd.DataFrame(\n d3,\n columns=[\"hobby\", \"children\"],\n index=[\"alice\", \"bob\"]\n )\nd4\n\n# It is also possible to create a `DataFrame` with a dictionary (or list) of dictionaries (or list):\n\npeople = pd.DataFrame({\n \"birthyear\": {\"alice\":1985, \"bob\": 1984, \"charles\": 1992},\n \"hobby\": {\"alice\":\"Biking\", \"bob\": \"Dancing\"},\n \"weight\": {\"alice\":68, \"bob\": 83, \"charles\": 112},\n \"children\": {\"bob\": 3, \"charles\": 0}\n})\npeople\n\n# ## Multi-indexing\n# If all columns are tuples of the same size, then they are understood as a multi-index. The same goes for row index labels. For example:\n\nd5 = pd.DataFrame(\n {\n (\"public\", \"birthyear\"):\n {(\"Paris\",\"alice\"):1985, (\"Paris\",\"bob\"): 1984, (\"London\",\"charles\"): 1992},\n (\"public\", \"hobby\"):\n {(\"Paris\",\"alice\"):\"Biking\", (\"Paris\",\"bob\"): \"Dancing\"},\n (\"private\", \"weight\"):\n {(\"Paris\",\"alice\"):68, (\"Paris\",\"bob\"): 83, (\"London\",\"charles\"): 112},\n (\"private\", \"children\"):\n {(\"Paris\", \"alice\"):np.nan, (\"Paris\",\"bob\"): 3, (\"London\",\"charles\"): 0}\n }\n)\nd5\n\n# You can now get a `DataFrame` containing all the `\"public\"` columns very simply:\n\nd5[\"public\"]\n\nd5[\"public\", \"hobby\"] # Same result as d5[\"public\"][\"hobby\"]\n\n# ## Dropping a level\n# Let's look at `d5` again:\n\nd5\n\n# There are two levels of columns, and two levels of indices. We can drop a column level by calling `droplevel()` (the same goes for indices):\n\nd5.columns = d5.columns.droplevel(level = 0)\nd5\n\n# ## Transposing\n# You can swap columns and indices using the `T` attribute:\n\nd6 = d5.T\nd6\n\n# ## Stacking and unstacking levels\n# Calling the `stack()` method will push the lowest column level after the lowest index:\n\nd7 = d6.stack()\nd7\n\n# Note that many `NaN` values appeared. This makes sense because many new combinations did not exist before (eg. there was no `bob` in `London`).\n#\n# Calling `unstack()` will do the reverse, once again creating many `NaN` values.\n\nd8 = d7.unstack()\nd8\n\n# If we call `unstack` again, we end up with a `Series` object:\n\nd9 = d8.unstack()\nd9\n\n# The `stack()` and `unstack()` methods let you select the `level` to stack/unstack. You can even stack/unstack multiple levels at once:\n\nd10 = d9.unstack(level = (0,1))\nd10\n\n# ## Most methods return modified copies\n# As you may have noticed, the `stack()` and `unstack()` methods do not modify the object they apply to. Instead, they work on a copy and return that copy. This is true of most methods in pandas.\n\n# ## Accessing rows\n# Let's go back to the `people` `DataFrame`:\n\npeople\n\n# The `loc` attribute lets you access rows instead of columns. The result is a `Series` object in which the `DataFrame`'s column names are mapped to row index labels:\n\npeople.loc[\"charles\"]\n\n# You can also access rows by integer location using the `iloc` attribute:\n\npeople.iloc[2]\n\n# You can also get a slice of rows, and this returns a `DataFrame` object:\n\npeople.iloc[1:3]\n\n# Finally, you can pass a boolean array to get the matching rows:\n\npeople[np.array([True, False, True])]\n\n# This is most useful when combined with boolean expressions:\n\npeople[people[\"birthyear\"] < 1990]\n\n# ## Adding and removing columns\n# You can generally treat `DataFrame` objects like dictionaries of `Series`, so the following work fine:\n\npeople\n\n# +\npeople[\"age\"] = 2018 - people[\"birthyear\"] # adds a new column \"age\"\npeople[\"over 30\"] = people[\"age\"] > 30 # adds another column \"over 30\"\nbirthyears = people.pop(\"birthyear\")\ndel people[\"children\"]\n\npeople\n# -\n\nbirthyears\n\n# When you add a new colum, it must have the same number of rows. Missing rows are filled with NaN, and extra rows are ignored:\n\npeople[\"pets\"] = pd.Series({\"bob\": 0, \"charles\": 5, \"eugene\":1}) # alice is missing, eugene is ignored\npeople\n\n# When adding a new column, it is added at the end (on the right) by default. You can also insert a column anywhere else using the `insert()` method:\n\npeople.insert(1, \"height\", [172, 181, 185])\npeople\n\n# ## Assigning new columns\n# You can also create new columns by calling the `assign()` method. Note that this returns a new `DataFrame` object, the original is not modified:\n\npeople.assign(\n body_mass_index = people[\"weight\"] / (people[\"height\"] / 100) ** 2,\n has_pets = people[\"pets\"] > 0\n)\n\n# Note that you cannot access columns created within the same assignment:\n\ntry:\n people.assign(\n body_mass_index = people[\"weight\"] / (people[\"height\"] / 100) ** 2,\n overweight = people[\"body_mass_index\"] > 25\n )\nexcept KeyError as e:\n print(\"Key error:\", e)\n\n# The solution is to split this assignment in two consecutive assignments:\n\nd6 = people.assign(body_mass_index = people[\"weight\"] / (people[\"height\"] / 100) ** 2)\nd6.assign(overweight = d6[\"body_mass_index\"] > 25)\n\n# Having to create a temporary variable `d6` is not very convenient. You may want to just chain the assigment calls, but it does not work because the `people` object is not actually modified by the first assignment:\n\ntry:\n (people\n .assign(body_mass_index = people[\"weight\"] / (people[\"height\"] / 100) ** 2)\n .assign(overweight = people[\"body_mass_index\"] > 25)\n )\nexcept KeyError as e:\n print(\"Key error:\", e)\n\n# But fear not, there is a simple solution. You can pass a function to the `assign()` method (typically a `lambda` function), and this function will be called with the `DataFrame` as a parameter:\n\n(people\n .assign(body_mass_index = lambda df: df[\"weight\"] / (df[\"height\"] / 100) ** 2)\n .assign(overweight = lambda df: df[\"body_mass_index\"] > 25)\n)\n\n# Problem solved!\n\n# ## Evaluating an expression\n# A great feature supported by pandas is expression evaluation. This relies on the `numexpr` library which must be installed.\n\npeople.eval(\"weight / (height/100) ** 2 > 25\")\n\n# Assignment expressions are also supported. Let's set `inplace=True` to directly modify the `DataFrame` rather than getting a modified copy:\n\npeople.eval(\"body_mass_index = weight / (height/100) ** 2\", inplace=True)\npeople\n\n# You can use a local or global variable in an expression by prefixing it with `'@'`:\n\noverweight_threshold = 30\npeople.eval(\"overweight = body_mass_index > @overweight_threshold\", inplace=True)\npeople\n\n# ## Querying a `DataFrame`\n# The `query()` method lets you filter a `DataFrame` based on a query expression:\n\npeople.query(\"age > 30 and pets == 0\")\n\n# ## Sorting a `DataFrame`\n# You can sort a `DataFrame` by calling its `sort_index` method. By default it sorts the rows by their index label, in ascending order, but let's reverse the order:\n\npeople.sort_index(ascending=False)\n\n# Note that `sort_index` returned a sorted *copy* of the `DataFrame`. To modify `people` directly, we can set the `inplace` argument to `True`. Also, we can sort the columns instead of the rows by setting `axis=1`:\n\npeople.sort_index(axis=1, inplace=True)\npeople\n\n# To sort the `DataFrame` by the values instead of the labels, we can use `sort_values` and specify the column to sort by:\n\npeople.sort_values(by=\"age\", inplace=True)\npeople\n\n# ## Plotting a `DataFrame`\n# Just like for `Series`, pandas makes it easy to draw nice graphs based on a `DataFrame`.\n#\n# For example, it is trivial to create a line plot from a `DataFrame`'s data by calling its `plot` method:\n\npeople.plot(kind = \"line\", x = \"body_mass_index\", y = [\"height\", \"weight\"])\nplt.show()\n\n# You can pass extra arguments supported by matplotlib's functions. For example, we can create scatterplot and pass it a list of sizes using the `s` argument of matplotlib's `scatter()` function:\n\npeople.plot(kind = \"scatter\", x = \"height\", y = \"weight\", s=[40, 120, 200])\nplt.show()\n\n# Again, there are way too many options to list here: the best option is to scroll through the [Visualization](http://pandas.pydata.org/pandas-docs/stable/visualization.html) page in pandas' documentation, find the plot you are interested in and look at the example code.\n\n# ## Operations on `DataFrame`s\n# Although `DataFrame`s do not try to mimick NumPy arrays, there are a few similarities. Let's create a `DataFrame` to demonstrate this:\n\ngrades_array = np.array([[8,8,9],[10,9,9],[4, 8, 2], [9, 10, 10]])\ngrades = pd.DataFrame(grades_array, columns=[\"sep\", \"oct\", \"nov\"], index=[\"alice\",\"bob\",\"charles\",\"darwin\"])\ngrades\n\n# You can apply NumPy mathematical functions on a `DataFrame`: the function is applied to all values:\n\nnp.sqrt(grades)\n\n# Similarly, adding a single value to a `DataFrame` will add that value to all elements in the `DataFrame`. This is called *broadcasting*:\n\ngrades + 1\n\n# Of course, the same is true for all other binary operations, including arithmetic (`*`,`/`,`**`...) and conditional (`>`, `==`...) operations:\n\ngrades >= 5\n\n# Aggregation operations, such as computing the `max`, the `sum` or the `mean` of a `DataFrame`, apply to each column, and you get back a `Series` object:\n\ngrades.mean()\n\n# The `all` method is also an aggregation operation: it checks whether all values are `True` or not. Let's see during which months all students got a grade greater than `5`:\n\n(grades > 5).all()\n\n# Most of these functions take an optional `axis` parameter which lets you specify along which axis of the `DataFrame` you want the operation executed. The default is `axis=0`, meaning that the operation is executed vertically (on each column). You can set `axis=1` to execute the operation horizontally (on each row). For example, let's find out which students had all grades greater than `5`:\n\n(grades > 5).all(axis = 1)\n\n# The `any` method returns `True` if any value is True. Let's see who got at least one grade 10:\n\n(grades == 10).any(axis = 1)\n\n# If you add a `Series` object to a `DataFrame` (or execute any other binary operation), pandas attempts to broadcast the operation to all *rows* in the `DataFrame`. This only works if the `Series` has the same size as the `DataFrame`s rows. For example, let's substract the `mean` of the `DataFrame` (a `Series` object) from the `DataFrame`:\n\ngrades - grades.mean() # equivalent to: grades - [7.75, 8.75, 7.50]\n\n# We substracted `7.75` from all September grades, `8.75` from October grades and `7.50` from November grades. It is equivalent to substracting this `DataFrame`:\n\npd.DataFrame([[7.75, 8.75, 7.50]]*4, index=grades.index, columns=grades.columns)\n\n# If you want to substract the global mean from every grade, here is one way to do it:\n\ngrades - grades.values.mean() # substracts the global mean (8.00) from all grades\n\n# ## Automatic alignment\n# Similar to `Series`, when operating on multiple `DataFrame`s, pandas automatically aligns them by row index label, but also by column names. Let's create a `DataFrame` with bonus points for each person from October to December:\n\nbonus_array = np.array([[0,np.nan,2],[np.nan,1,0],[0, 1, 0], [3, 3, 0]])\nbonus_points = pd.DataFrame(bonus_array, columns=[\"oct\", \"nov\", \"dec\"], index=[\"bob\",\"colin\", \"darwin\", \"charles\"])\nbonus_points\n\ngrades + bonus_points\n\n# Looks like the addition worked in some cases but way too many elements are now empty. That's because when aligning the `DataFrame`s, some columns and rows were only present on one side, and thus they were considered missing on the other side (`NaN`). Then adding `NaN` to a number results in `NaN`, hence the result.\n#\n# ## Handling missing data\n# Dealing with missing data is a frequent task when working with real life data. Pandas offers a few tools to handle missing data.\n# \n# Let's try to fix the problem above. For example, we can decide that missing data should result in a zero, instead of `NaN`. We can replace all `NaN` values by a any value using the `fillna()` method:\n\n(grades + bonus_points).fillna(0)\n\n# It's a bit unfair that we're setting grades to zero in September, though. Perhaps we should decide that missing grades are missing grades, but missing bonus points should be replaced by zeros:\n\nfixed_bonus_points = bonus_points.fillna(0)\nfixed_bonus_points.insert(0, \"sep\", 0)\nfixed_bonus_points.loc[\"alice\"] = 0\ngrades + fixed_bonus_points\n\n# That's much better: although we made up some data, we have not been too unfair.\n#\n# Another way to handle missing data is to interpolate. Let's look at the `bonus_points` `DataFrame` again:\n\nbonus_points\n\n# Now let's call the `interpolate` method. By default, it interpolates vertically (`axis=0`), so let's tell it to interpolate horizontally (`axis=1`).\n\nbonus_points.interpolate(axis=1)\n\n# Bob had 0 bonus points in October, and 2 in December. When we interpolate for November, we get the mean: 1 bonus point. Colin had 1 bonus point in November, but we do not know how many bonus points he had in September, so we cannot interpolate, this is why there is still a missing value in October after interpolation. To fix this, we can set the September bonus points to 0 before interpolation.\n\nbetter_bonus_points = bonus_points.copy()\nbetter_bonus_points.insert(0, \"sep\", 0)\nbetter_bonus_points.loc[\"alice\"] = 0\nbetter_bonus_points = better_bonus_points.interpolate(axis=1)\nbetter_bonus_points\n\n# Great, now we have reasonable bonus points everywhere. Let's find out the final grades:\n\ngrades + better_bonus_points\n\n# It is slightly annoying that the September column ends up on the right. This is because the `DataFrame`s we are adding do not have the exact same columns (the `grades` `DataFrame` is missing the `\"dec\"` column), so to make things predictable, pandas orders the final columns alphabetically. To fix this, we can simply add the missing column before adding:\n\ngrades[\"dec\"] = np.nan\nfinal_grades = grades + better_bonus_points\nfinal_grades\n\n# There's not much we can do about December and Colin: it's bad enough that we are making up bonus points, but we can't reasonably make up grades (well I guess some teachers probably do). So let's call the `dropna()` method to get rid of rows that are full of `NaN`s:\n\nfinal_grades_clean = final_grades.dropna(how=\"all\")\nfinal_grades_clean\n\n# Now let's remove columns that are full of `NaN`s by setting the `axis` argument to `1`:\n\nfinal_grades_clean = final_grades_clean.dropna(axis=1, how=\"all\")\nfinal_grades_clean\n\n# ## Aggregating with `groupby`\n# Similar to the SQL language, pandas allows grouping your data into groups to run calculations over each group.\n#\n# First, let's add some extra data about each person so we can group them, and let's go back to the `final_grades` `DataFrame` so we can see how `NaN` values are handled:\n\nfinal_grades[\"hobby\"] = [\"Biking\", \"Dancing\", np.nan, \"Dancing\", \"Biking\"]\nfinal_grades\n\n# Now let's group data in this `DataFrame` by hobby:\n\ngrouped_grades = final_grades.groupby(\"hobby\")\ngrouped_grades\n\n# We are ready to compute the average grade per hobby:\n\ngrouped_grades.mean()\n\n# That was easy! Note that the `NaN` values have simply been skipped when computing the means.\n\n# ## Pivot tables\n# Pandas supports spreadsheet-like [pivot tables](https://en.wikipedia.org/wiki/Pivot_table) that allow quick data summarization. To illustrate this, let's create a simple `DataFrame`:\n\nbonus_points\n\nmore_grades = final_grades_clean.stack().reset_index()\nmore_grades.columns = [\"name\", \"month\", \"grade\"]\nmore_grades[\"bonus\"] = [np.nan, np.nan, np.nan, 0, np.nan, 2, 3, 3, 0, 0, 1, 0]\nmore_grades\n\n# Now we can call the `pd.pivot_table()` function for this `DataFrame`, asking to group by the `name` column. By default, `pivot_table()` computes the mean of each numeric column:\n\npd.pivot_table(more_grades, index=\"name\")\n\n# We can change the aggregation function by setting the `aggfunc` argument, and we can also specify the list of columns whose values will be aggregated:\n\npd.pivot_table(more_grades, index=\"name\", values=[\"grade\",\"bonus\"], aggfunc=np.max)\n\n# We can also specify the `columns` to aggregate over horizontally, and request the grand totals for each row and column by setting `margins=True`:\n\npd.pivot_table(more_grades, index=\"name\", values=\"grade\", columns=\"month\", margins=True)\n\n# Finally, we can specify multiple index or column names, and pandas will create multi-level indices:\n\npd.pivot_table(more_grades, index=(\"name\", \"month\"), margins=True)\n\n# ## Overview functions\n# When dealing with large `DataFrames`, it is useful to get a quick overview of its content. Pandas offers a few functions for this. First, let's create a large `DataFrame` with a mix of numeric values, missing values and text values. Notice how Jupyter displays only the corners of the `DataFrame`:\n\nmuch_data = np.fromfunction(lambda x,y: (x+y*y)%17*11, (10000, 26))\nlarge_df = pd.DataFrame(much_data, columns=list(\"ABCDEFGHIJKLMNOPQRSTUVWXYZ\"))\nlarge_df[large_df % 16 == 0] = np.nan\nlarge_df.insert(3,\"some_text\", \"Blabla\")\nlarge_df\n\n# The `head()` method returns the top 5 rows:\n\nlarge_df.head()\n\n# Of course there's also a `tail()` function to view the bottom 5 rows. You can pass the number of rows you want:\n\nlarge_df.tail(n=2)\n\n# The `info()` method prints out a summary of each columns contents:\n\nlarge_df.info()\n\n# Finally, the `describe()` method gives a nice overview of the main aggregated values over each column:\n# * `count`: number of non-null (not NaN) values\n# * `mean`: mean of non-null values\n# * `std`: [standard deviation](https://en.wikipedia.org/wiki/Standard_deviation) of non-null values\n# * `min`: minimum of non-null values\n# * `25%`, `50%`, `75%`: 25th, 50th and 75th [percentile](https://en.wikipedia.org/wiki/Percentile) of non-null values\n# * `max`: maximum of non-null values\n\nlarge_df.describe()\n\n# # Saving & loading\n# Pandas can save `DataFrame`s to various backends, including file formats such as CSV, Excel, JSON, HTML and HDF5, or to a SQL database. Let's create a `DataFrame` to demonstrate this:\n\nmy_df = pd.DataFrame(\n [[\"Biking\", 68.5, 1985, np.nan], [\"Dancing\", 83.1, 1984, 3]], \n columns=[\"hobby\",\"weight\",\"birthyear\",\"children\"],\n index=[\"alice\", \"bob\"]\n)\nmy_df\n\n# ## Saving\n# Let's save it to CSV, HTML and JSON:\n\nmy_df.to_csv(\"my_df.csv\")\nmy_df.to_html(\"my_df.html\")\nmy_df.to_json(\"my_df.json\")\n\n# Done! Let's take a peek at what was saved:\n\nfor filename in (\"my_df.csv\", \"my_df.html\", \"my_df.json\"):\n print(\"#\", filename)\n with open(filename, \"rt\") as f:\n print(f.read())\n print()\n\n\n# Note that the index is saved as the first column (with no name) in a CSV file, as `<th>` tags in HTML and as keys in JSON.\n#\n# Saving to other formats works very similarly, but some formats require extra libraries to be installed. For example, saving to Excel requires the openpyxl library:\n\ntry:\n my_df.to_excel(\"my_df.xlsx\", sheet_name='People')\nexcept ImportError as e:\n print(e)\n\n# ## Loading\n# Now let's load our CSV file back into a `DataFrame`:\n\nmy_df_loaded = pd.read_csv(\"my_df.csv\", index_col=0)\nmy_df_loaded\n\n# As you might guess, there are similar `read_json`, `read_html`, `read_excel` functions as well. We can also read data straight from the Internet. For example, let's load all U.S. cities from [simplemaps.com](http://simplemaps.com/):\n\nus_cities = None\ntry:\n csv_url = \"http://simplemaps.com/files/cities.csv\"\n us_cities = pd.read_csv(csv_url, index_col=0)\n us_cities = us_cities.head()\nexcept IOError as e:\n print(e)\nus_cities\n\n# There are more options available, in particular regarding datetime format. Check out the [documentation](http://pandas.pydata.org/pandas-docs/stable/io.html) for more details.\n\n# # Combining `DataFrame`s\n#\n# ## SQL-like joins\n# One powerful feature of pandas is it's ability to perform SQL-like joins on `DataFrame`s. Various types of joins are supported: inner joins, left/right outer joins and full joins. To illustrate this, let's start by creating a couple simple `DataFrame`s:\n\ncity_loc = pd.DataFrame(\n [\n [\"CA\", \"San Francisco\", 37.781334, -122.416728],\n [\"NY\", \"New York\", 40.705649, -74.008344],\n [\"FL\", \"Miami\", 25.791100, -80.320733],\n [\"OH\", \"Cleveland\", 41.473508, -81.739791],\n [\"UT\", \"Salt Lake City\", 40.755851, -111.896657]\n ], columns=[\"state\", \"city\", \"lat\", \"lng\"])\ncity_loc\n\ncity_pop = pd.DataFrame(\n [\n [808976, \"San Francisco\", \"California\"],\n [8363710, \"New York\", \"New-York\"],\n [413201, \"Miami\", \"Florida\"],\n [2242193, \"Houston\", \"Texas\"]\n ], index=[3,4,5,6], columns=[\"population\", \"city\", \"state\"])\ncity_pop\n\n# Now let's join these `DataFrame`s using the `merge()` function:\n\npd.merge(left=city_loc, right=city_pop, on=\"city\")\n\n# Note that both `DataFrame`s have a column named `state`, so in the result they got renamed to `state_x` and `state_y`.\n#\n# Also, note that Cleveland, Salt Lake City and Houston were dropped because they don't exist in *both* `DataFrame`s. This is the equivalent of a SQL `INNER JOIN`. If you want a `FULL OUTER JOIN`, where no city gets dropped and `NaN` values are added, you must specify `how=\"outer\"`:\n\nall_cities = pd.merge(left=city_loc, right=city_pop, on=\"city\", how=\"outer\")\nall_cities\n\n# Of course `LEFT OUTER JOIN` is also available by setting `how=\"left\"`: only the cities present in the left `DataFrame` end up in the result. Similarly, with `how=\"right\"` only cities in the right `DataFrame` appear in the result. For example:\n\npd.merge(left=city_loc, right=city_pop, on=\"city\", how=\"right\")\n\n# If the key to join on is actually in one (or both) `DataFrame`'s index, you must use `left_index=True` and/or `right_index=True`. If the key column names differ, you must use `left_on` and `right_on`. For example:\n\ncity_pop2 = city_pop.copy()\ncity_pop2.columns = [\"population\", \"name\", \"state\"]\npd.merge(left=city_loc, right=city_pop2, left_on=\"city\", right_on=\"name\")\n\n# ## Concatenation\n# Rather than joining `DataFrame`s, we may just want to concatenate them. That's what `concat()` is for:\n\nresult_concat = pd.concat([city_loc, city_pop])\nresult_concat\n\n# Note that this operation aligned the data horizontally (by columns) but not vertically (by rows). In this example, we end up with multiple rows having the same index (eg. 3). Pandas handles this rather gracefully:\n\nresult_concat.loc[3]\n\n# Or you can tell pandas to just ignore the index:\n\npd.concat([city_loc, city_pop], ignore_index=True)\n\n# Notice that when a column does not exist in a `DataFrame`, it acts as if it was filled with `NaN` values. If we set `join=\"inner\"`, then only columns that exist in *both* `DataFrame`s are returned:\n\npd.concat([city_loc, city_pop], join=\"inner\")\n\n# You can concatenate `DataFrame`s horizontally instead of vertically by setting `axis=1`:\n\npd.concat([city_loc, city_pop], axis=1)\n\n# In this case it really does not make much sense because the indices do not align well (eg. Cleveland and San Francisco end up on the same row, because they shared the index label `3`). So let's reindex the `DataFrame`s by city name before concatenating:\n\npd.concat([city_loc.set_index(\"city\"), city_pop.set_index(\"city\")], axis=1)\n\n# This looks a lot like a `FULL OUTER JOIN`, except that the `state` columns were not renamed to `state_x` and `state_y`, and the `city` column is now the index.\n\n# The `append()` method is a useful shorthand for concatenating `DataFrame`s vertically:\n\ncity_loc.append(city_pop)\n\n# As always in pandas, the `append()` method does *not* actually modify `city_loc`: it works on a copy and returns the modified copy.\n\n# # Categories\n# It is quite frequent to have values that represent categories, for example `1` for female and `2` for male, or `\"A\"` for Good, `\"B\"` for Average, `\"C\"` for Bad. These categorical values can be hard to read and cumbersome to handle, but fortunately pandas makes it easy. To illustrate this, let's take the `city_pop` `DataFrame` we created earlier, and add a column that represents a category:\n\ncity_eco = city_pop.copy()\ncity_eco[\"eco_code\"] = [17, 17, 34, 20]\ncity_eco\n\n# Right now the `eco_code` column is full of apparently meaningless codes. Let's fix that. First, we will create a new categorical column based on the `eco_code`s:\n\ncity_eco[\"economy\"] = city_eco[\"eco_code\"].astype('category')\ncity_eco[\"economy\"].cat.categories\n\n# Now we can give each category a meaningful name:\n\ncity_eco[\"economy\"].cat.categories = [\"Finance\", \"Energy\", \"Tourism\"]\ncity_eco\n\n# Note that categorical values are sorted according to their categorical order, *not* their alphabetical order:\n\ncity_eco.sort_values(by=\"economy\", ascending=False)\n\n# # What next?\n# As you probably noticed by now, pandas is quite a large library with *many* features. Although we went through the most important features, there is still a lot to discover. Probably the best way to learn more is to get your hands dirty with some real-life data. It is also a good idea to go through pandas' excellent [documentation](http://pandas.pydata.org/pandas-docs/stable/index.html), in particular the [Cookbook](http://pandas.pydata.org/pandas-docs/stable/cookbook.html).\n\n\n"},"script_size":{"kind":"number","value":39451,"string":"39,451"}}},{"rowIdx":76,"cells":{"path":{"kind":"string","value":"/python/deeplearning/sonar_data_analysis.ipynb"},"content_id":{"kind":"string","value":"ba9481f11fbf685b6aeaebb3308ba58b05b55752"},"detected_licenses":{"kind":"list like","value":[],"string":"[]","isConversational":false},"license_type":{"kind":"string","value":"no_license"},"repo_name":{"kind":"string","value":"KANGSUNGHO/StudySpace"},"repo_url":{"kind":"string","value":"https://github.com/KANGSUNGHO/StudySpace"},"star_events_count":{"kind":"number","value":0,"string":"0"},"fork_events_count":{"kind":"number","value":0,"string":"0"},"gha_license_id":{"kind":"null"},"gha_event_created_at":{"kind":"null"},"gha_updated_at":{"kind":"null"},"gha_language":{"kind":"null"},"language":{"kind":"string","value":"Jupyter Notebook"},"is_generated":{"kind":"bool","value":false,"string":"false"},"is_vendor":{"kind":"bool","value":false,"string":"false"},"conversion_extension":{"kind":"string","value":".py"},"size":{"kind":"number","value":33916,"string":"33,916"},"script":{"kind":"string","value":"# ---\n# jupyter:\n# jupytext:\n# text_representation:\n# extension: .py\n# format_name: light\n# format_version: '1.5'\n# jupytext_version: 1.15.2\n# kernelspec:\n# display_name: Python 3\n# language: python\n# name: python3\n# ---\n\nimport math\n\n\ndef primeFact(n):\n while(n % 2 == 0):\n n = n // 2\n yield 2\n \n for i in range(3,round(math.sqrt(n)),2):\n while(n % i == 0):\n n = n // i\n yield i\n \n if n > 2:\n yield n\n\n\nfor i in primeFact(81):\n print(i)\n\nprimeFact(81)\n\n\nth labels, etc.\n#\n\nimport matplotlib.pyplot as plt\n\nplt.plot([2, 4, 6, 4])\nplt.ylabel('Numbers')\nplt.xlabel('Indices')\nplt.title('Myplot')\nplt.show()\n\n# If you provide a single list or array to the plot() command, matplotlib assumes it is a sequence of y values, and automatically generates the x values for you. Since python ranges start with 0, the default x vector has the same length as y but starts with 0. Hence the x data are [0,1,2,3].\n#\n\n# **plot x versus y**\n\nplt.plot([1, 2, 3, 4], [1, 4, 9, 16])\nplt.ylabel('squares')\nplt.xlabel('numbers')\nplt.grid() #grid on\nplt.show()\n\n# For every x, y pair of arguments, there is an optional third argument which is the **format string** that indicates the color and line type of the plot. \n\nplt.plot([1, 2, 3, 4], [1, 4, 9, 16], 'ro') #ro- red-dot(o shape)\nplt.grid()\nplt.show()\n\n# If matplotlib were limited to working with lists, it would be fairly useless for numeric processing. Generally, you will use **numpy arrays**. In fact, all sequences are converted to numpy arrays internally.\n#\n\nimport numpy as np\n\n# +\nt = np.arange(0., 5., 0.2)\n\n# blue dashes, red squares and green triangles\nplt.plot(t, t**2, 'b--', label='^2')\nplt.plot(t, t**2.2, 'rs', label='^2.2')\nplt.plot(t, t**2.5, 'g^', label='^2.5')\nplt.grid()\nplt.legend() #add legend based on line labels\nplt.show()\n# -\n\n# ## Controlling line properties\n#\n#\n# **use keyword args**\n\nx = [1, 2, 3, 4]\ny = [1, 4, 9, 16]\nplt.plot(x, y, linewidth=5.0)\nplt.show()\n\n# **use the setp()**\n\n# +\nx1 = [1, 2, 3, 4]\ny1 = [1, 4, 9, 16]\nx2 = [1, 2, 3, 4]\ny2 = [2, 4, 6, 8]\nlines = plt.plot(x1, y1, x2, y2)\n\n# use keyword args\nplt.setp(lines[0], color='r', linewidth=2.0) #setp= set properties\n\n# or MATLAB style string value pairs\nplt.setp(lines[1], 'color', 'g', 'linewidth', 2.0)\n\nplt.grid()\n\n\n# -\n\n# ## working with multiple figures and axes\n#\n\n# +\ndef f(t):\n return np.exp(-t) * np.cos(2*np.pi*t)\n\nt1 = np.arange(0.0, 5.0, 0.1)\nt2 = np.arange(0.0, 5.0, 0.02)\n\nplt.figure(1)\n\n# the subplot() command specifies numrows, numcols, \n# fignum where fignum ranges from 1 to numrows*numcols.\nplt.subplot(211)\nplt.grid()\nplt.plot(t1, f(t1), 'b--')\n\nplt.subplot(212)\nplt.plot(t2, np.cos(2*np.pi*t2), 'r--')\nplt.show()\n\n# +\nplt.figure(1) #the first figure\nplt.subplot(211) #the first subplot in the first figure\nplt.plot([1, 2, 3])\nplt.subplot(212) #the second subplot in the first figure\n\nplt.figure(2) #a second figure\nplt.plot([4, 5, 6]) #creates a subplot(111) by default\n\nplt.figure(1) #figure 1 current; subplot(212 still current\nplt.subplot(211) #make subplot(211) in figure 1 current\nplt.title('Easy as 1, 2, 3') #subplot 211 title\nplt.show()\ntives using autograd functionality `grad()`:\n# \n# 1. **(1 pt.)** Plot `ReLU`, `ELU` ($\\alpha = 1$), `Softplus` ($\\beta = 1$) and `Sign`, `Sigmoid`, `Softsign`, `Tanh`.\n# Which of these functions may be, and which - definitely, are a poor choise as an activation function in a neural network? Why?\n\n# +\n# %matplotlib inline\nimport torch.nn.functional as F\nimport matplotlib.pyplot as plt\nimport torch\n\nx = torch.arange(-2, 2, .01, requires_grad=True)\nx_np = x.detach().numpy()\nx.sum().backward() # to create x.grad\n\nf, axes = plt.subplots(2, 2, sharex=True, figsize=(14, 5))\naxes[0, 0].set_title('Values')\naxes[0, 1].set_title('Derivatives')\n\nfor i, function_set in (0, (('ReLU', F.relu), ('ELU', F.elu), ('Softplus', F.softplus))), \\\n (1, (('Sign', torch.sign), ('Sigmoid', torch.sigmoid), ('Softsign', F.softsign), ('Tanh', torch.tanh))):\n for function_name, activation in function_set:\n ### BEGIN Solution\n x.grad.zero_()\n xs = x.detach().numpy()\n values = activation(x).data.numpy()\n activation(x).sum().backward()\n derivatives = x.grad.data.numpy()\n axes[i, 0].plot(xs, values, label = function_name)\n axes[i, 1].plot(xs, derivatives , label=function_name)\n ### END Solution\n\n axes[i, 0].legend()\n axes[i, 1].legend()\n\nplt.tight_layout()\nplt.show()\n# -\n\n# ### Task 1.2. MNIST classification. (4 points)\n#\n# At the **Seminar 10** on neural networks, we built an MLP (Multilayer perceptron) with one hidden layer using our numpy implementations of linear layer and logistic and softmax activation functions. Your task is to\n#\n# 1. **(1 pt.)** Implement the MPL modules, including the Softmax cross entropy between `logits` and `labels`.\n# 2. **(2 pt.)** Train our numpy realization of MLP to classify the MNIST from `sklearn.datasets()`. Getting accuracy on validation `> 90%`.\n# 3. **(1 pt.)** Compare the acccuracy of classification to your scores from `Part 1` with and without dimensionality reduction. Will be this comparison fair? :) Derive the confusion matrix for all digits classes. What digits were predicted better or worse, than others?\n#\n\nfrom sklearn.metrics import confusion_matrix, accuracy_score\nfrom sklearn.datasets import load_digits\nimport numpy as np\nimport pandas as pd\nimport matplotlib.pyplot as plt\nfrom sklearn.model_selection import train_test_split\n\n# +\n# fetch the dataset.\ndigits, targets = load_digits(return_X_y=True)\ndigits = digits.astype(np.float32) / 255\n\ndigits_train, digits_test, targets_train, targets_test = train_test_split(digits, targets, random_state=0)\n\ntrain_size = digits_train.shape[0]\n\ninput_size = 8*8\nclasses_n = 10\n# -\n\ndigits.shape\n\n\n# **Implement the MLP with backprop.**\n\n# +\nclass Linear:\n def __init__(self, input_size, output_size):\n self.thetas = np.random.randn(input_size, output_size)\n self.thetas_grads = np.empty_like(self.thetas)\n self.bias = np.random.randn(output_size).reshape(-1, 1)\n self.bias_grads = np.empty_like(self.bias).reshape(-1, 1)\n\n def forward(self, x): \n self.x = x\n# print('forward_linear')\n# print('linear forward, x shape: ', x.shape)\n# print('linear forward, thetas.shape: ',self.thetas.shape)\n# print('linear forward bias shape: ', self.bias.shape)\n return np.dot(x, self.thetas.T) + self.bias\n \n def backward(self, x, output_grad):\n ### BEGIN Solution\n print('backward_linear')\n print('backward_linear output_grad.shape: ', output_grad.shape)\n print('backward_linear thetas.shape: ', self.thetas.shape)\n print('backward_linear bias_grads shape: ', self.bias_grads.shape)\n print('backprob x shape', x.shape)\n print('backprob self.x shape', self.x.shape)\n self.thetas_grads += np.dot(self.x, output_grad.T)\n self.bias_grads += np.sum(output_grad, axis=1, keepdims=True)\n ### END Solution\n return np.dot(self.thetas, output_grad)\n \nclass LogisticActivation:\n def forward(self, x):\n #print('forward_logistic')\n self.x = x\n self.output = 1.0/(1 + np.exp(-x))\n return self.output\n\n\n def backward(self, x, output_grad):\n ### BEGIN Solution\n #print('backward_logistic')\n a = self.output.reshape(-1, 1)\n b = 1 - a\n c = a*b\n input_grad = c.T * output_grad\n ### END Solution\n return input_grad\n \n\nclass MLP:\n def __init__(self, input_size, hidden_layer_size, output_size):\n self.linear1 = Linear(input_size, hidden_layer_size)\n self.activation1 = LogisticActivation()\n self.linear2 = Linear(hidden_layer_size, output_size)\n \n \n def forward(self, x):\n #print('forward_mlp')\n asd = self.linear2.forward(self.activation1.forward(self.linear1.forward(x)))\n return np.exp(asd) / np.sum(np.exp(asd), axis = 0, keepdims=True)\n\n\n def backward(self, x, output_grad):\n #print('backward_mlp')\n output = self.linear1.backward(x, self.activation1.backward(x,self.linear2.backward(x,output_grad)))\n return output\n\n\n# +\n### BEGIN Solution \ndef softmax_crossentropy_with_logits(logits, reference_answers):\n logits_vec = np.zeros(logits.shape)\n logits_vec[reference_answers, :] = 1\n return -np.sum(logits_vec*np.log(logits) + (1-logits_vec)*np.log(1-logits), axis=0)\n\n\ndef grad_softmax_crossentropy_with_logits(logits, reference_answers):\n logits_vec = np.zeros(logits.shape)\n logits_vec[reference_answers, :] = 1\n out = logits_vec - logits\n return out\n### END Solution\n\n\n# +\ndef softmax_crossentropy_with_logits(logits,reference_answers):\n \"\"\"Compute crossentropy from logits[batch,n_classes] and ids of correct answers\"\"\"\n logits_for_answers = logits[np.arange(len(logits)),reference_answers]\n \n xentropy = - logits_for_answers + np.log(np.sum(np.exp(logits),axis=-1))\n \n return xentropy\n\ndef grad_softmax_crossentropy_with_logits(logits,reference_answers):\n \"\"\"Compute crossentropy gradient from logits[batch,n_classes] and ids of correct answers\"\"\"\n ones_for_answers = np.zeros_like(logits)\n ones_for_answers[np.arange(len(logits)),reference_answers] = 1\n \n softmax = np.exp(logits) / np.exp(logits).sum(axis=-1,keepdims=True)\n \n return (- ones_for_answers + softmax) / logits.shape[0]\n\n\n# +\nnp.random.seed(42)\n\nmlp = MLP(input_size=input_size, hidden_layer_size=100, output_size=classes_n)\n\nepochs_n = 100\nlearning_curve = [0] * epochs_n\ntest_curve = [0] * epochs_n\n\nx_train = digits_train\nx_test = digits_test\ny_train = targets_train\ny_test = targets_test\n\nlearning_rate = 1e-2\n\nfor epoch in range(epochs_n):\n \n for sample_i in range(train_size):\n x = x_train[sample_i].reshape(-1, 1)\n #print('x shape: ',x.shape)\n target = np.array([y_train[sample_i]])\n ### BEGIN Solution\n mlp.linear1.thetas_grads = np.zeros_like(mlp.linear1.thetas_grads)\n mlp.linear2.thetas_grads = np.zeros_like(mlp.linear2.thetas_grads)\n mlp.linear1.bias_grads = np.zeros_like(mlp.linear1.bias_grads)\n mlp.linear2.bias_grads = np.zeros_like(mlp.linear2.bias_grads)\n prediction = mlp.forward(x)\n loss = softmax_crossentropy_with_logits(prediction, target)\n print(prediction)\n grad_loss = grad_softmax_crossentropy_with_logits(prediction, target)\n learning_curve[epoch] += loss\n mlp.backward(x, grad_loss)\n \n mlp.linear1.thetas -= mlp.linear1.thetas_grads * learning_rate\n mlp.linear2.thetas -= mlp.linear2.thetas_grads * learning_rate\n mlp.linear1.bias -= mlp.linear1.bias_grads * learning_rate\n mlp.linear2.bias -= mlp.linear2.bias_grads * learning_rate\n learning_curve[epoch] /= train_size\n preds = []\n #print(loss)\n for sample_i in range(digits_test.shape[0]):\n x = x_test[sample_i].reshape(-1, 1)\n target = np.array([y_test[sample_i]])\n pred = mlp.forward(x)\n loss = softmax_crossentropy_with_logits(pred, target)\n test_curve[epoch] += loss\n preds.append(np.argmax(pred, axis=0))\n acc = accuracy_score(preds, y_test)\n test_curve[epoch] /=digits_test.shape[0]\n\n if epoch % 10 == 0:\n print('Starting epoch {}'.format(epoch),', Accuracy on test: ', acc)\n\n print()\n\n ### END Solution\nplt.plot(learning_curve,label='learning')\nplt.plot(test_curve, label='test')\nplt.legend()\n# -\n\n# confusion matrix\npredictions = mlp.forward(digits).argmax(axis = 1)\npd.DataFrame(confusion_matrix(targets, predictions))\n# >>> your solution here <<<\n\n# - Number 1, 3, 9 and 7 were predicted worse compared to other numbers. Thus is due to some similarity between numbers. The only strange thing is that there are 18 confusions between '1' and '8'. This result is worse compared to KNN with PCA from part 1, but such comparison is not fare since PCA provides great advantage by culling low-variance features.\n\n# ## Task 2. Autoencoders. (7 points)\n#\n# ### Task 2.1. Autoencoder on the tabular data. (3 points)\n#\n#\n# We will biuld the latent representation for tabular data with simple Autoencoding (AE) network. We will work with the cancer dataset from the scikit-learn package. You are to follow the instructions `1.0 - 1.6`. \n#\n# 1. **(1 pt.)** Implement the AE modules;\n# 2. **(2 pt.)** Train AE to get latent representation of the cancer dataset from `sklearn.datasets()`. Use `MSE` loss and get < $0.28$ on validation, with AE \"bottleneck\" = $2$;\n# 3. **(1 pt.)** Plot the latent representation of whole dataset in 2D and use colors to show object of differneet classes;\n\n# +\n# imports\nimport sklearn.datasets as sk_data\nfrom sklearn.model_selection import train_test_split\nfrom sklearn.linear_model import LogisticRegression\nfrom sklearn.preprocessing import StandardScaler\n\nimport torch\nimport torch.nn as nn\nimport torch.utils.data as torch_data\n# -\n\n# #### 1.0 Featch the data. Scale it and split on train and test.\n\n# +\ncancer_dset = sk_data.load_breast_cancer()\n\nX = StandardScaler().fit_transform(cancer_dset['data'])\n\nprint('Features: ', list(cancer_dset['feature_names']))\nprint('\\nShape:', X.shape)\n\nX_train, X_val, y_train, y_val = train_test_split(X, cancer_dset['target'], test_size=0.2, random_state=42)\nprint('\\nTrain size: ', len(X_train))\nprint('Validation size: ', len(X_val))\n\n\n# -\n\n# #### 1.1 Let us firtly make the dataset, which we'll be able to use with pytorch dataloader. \n# Implement the `__len__` and `__getitem__` methods.\n\nclass CancerData(torch_data.Dataset):\n def __init__(self, X, y):\n super(CancerData, self).__init__()\n self.X = torch.tensor(X, dtype=torch.float32)\n self.y = torch.tensor(y, dtype=torch.float32)\n \n def __len__(self):\n return self.X.shape[0]\n \n def __getitem__(self, idx):\n return self.X[idx].unsqueeze(0), self.y[idx]\n\n\n# +\ntrain_dset = CancerData(X_train, y_train) \nval_dset = CancerData(X_val, y_val) \n\nprint(train_dset[5])\n\n\n# -\n\n# #### 1.2 Now, we'll be making a base class for out autoencoder. \n# It takes as input encoder and decoder (it will be tow neural networks). Using this two oblects, your task is to implement the forward pass.\n\nclass MyFirstAE(nn.Module):\n def __init__(self, encoder, decoder):\n super(MyFirstAE, self).__init__()\n self.encoder = encoder\n self.decoder = decoder\n \n def forward(self, x):\n \"\"\"\n Take a mini-batch as an input, encode it to the latent space and decode back to the original space\n x_out = decoder(encoder(x))\n :param x: torch.tensor, (MB, x_dim)\n :return: torch.tensor, (MB, x_dim)\n \"\"\" \n return self.decoder(self.encoder(x))# >>> your solution here <<<\n\n\n# #### 1.3 It is time to create neural networks for encoder an decoder networks.\n# Make hidden size of the network to be equal to `2`.\n#\n# **Hint.** You can use `nn.Sequential` to create your archtectures.\n\n# +\nss = 200\nsample_size = X.shape[1]\n\nencoder = nn.Sequential(\n nn.Linear(sample_size, ss*1),\n \n nn.ReLU(inplace=True),\n nn.Linear(ss*1,2)\n ) \n\ndecoder = nn.Sequential(\n nn.Linear(2, ss*1),\n \n nn.ReLU(inplace=True),\n nn.Linear(ss*1, sample_size) \n )\n\n# +\ndevice = 'cpu'\n\nnet = MyFirstAE(encoder, decoder) \ncriterion = nn.MSELoss()\noptimizer = torch.optim.Adam(net.parameters(), lr=1e-2)\nscheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=50, gamma=0.7)\n\n\ntrain_loader = torch_data.DataLoader(train_dset, batch_size=100, shuffle=True) \nval_loader = torch_data.DataLoader(val_dset, batch_size=100, shuffle=False) \n\n\n# -\n\n# #### 1.4 Implement the missing parts in the `train` function\n\ndef train(epochs, net, criterion, optimizer, train_loader, val_loader,scheduler=None, verbose=True, save_dir=None):\n net.to(device)\n for epoch in range(1, epochs+1):\n net.train()\n for X, _ in train_loader:\n # >>> your solution here <<<\n X = X.to(device)\n out = net(X)\n loss = criterion(out, X)\n \n optimizer.zero_grad()\n \n loss.backward()\n optimizer.step()\n # defining NN evaluation\n net.eval()\n for X, _ in val_loader:\n \n # >>> your solution here <<<\n X = X.to(device)\n out = net(X)\n val_loss = criterion(out, X)\n \n if scheduler is not None:\n scheduler.step()\n freq = max(epochs//20,1)\n if verbose and epoch%freq==0:\n print('Epoch {}/{} || Loss: Train {:.4f} | Validation {:.4f}'.format(epoch, epochs, loss.item(), val_loss.item()))\n\n\n# #### 1.5 Train your AE on breast cancer dataset. \n# Your goal is to get validation error < that 0.3.\n#\n# Some feartures that mey help you to improve performance:\n# * `Dropout`\n# * `Batchnorm`\n# * lr scheduler (e.g. reduce learning)\n# * Batch size\n\n# for `MSE` loss get < 0.28 on validation, with AE \"bottleneck\" = 2\ntrain(100, net, criterion, optimizer, train_loader, val_loader, scheduler) \n\n# #### 1.6 Let's take a look at the latent space. \n# Encode the whole dataset, using your AE, plot it in 2D and use colors to show object of differneet classes\n\n# +\n ### BEGIN Solution\nplt.figure(figsize=(14, 5))\nnet.eval()\n\nenc = net.encoder(torch.from_numpy(X).float()).detach().numpy()\nplt.scatter(enc[:,0], enc[:,1], c=cancer_dset['target'], alpha=0.7);\nplt.title('Latent space from the Autoencoder bottle neck, purple dots go for malignant samples. ');\n ### END Solution\n\n\n# -\n\n# ### Task 2.2. Autoencoder on kMNIST. (4 points)\n#\n#\n# We will build the latent representation for `kMRIST` dataset, which you are already familiar with, using our AE network. We will work with the data from `Part 1`.\n#\n# 1. **(2 pt.)** Train AE to get latent representation of the `kMNIST` dataset from `sklearn.datasets()`. Follow the instructions `2.0 - 2.4`. Use `MSE` loss and get < $0.035$ on validation, with AE \"bottleneck\" < $40$;\n# 2. **(1 pt.)** Plot 10 images and their reconstructions. Plot the latent representation of the whole dataset in 3D, compare visually to your manifold from `Part 1` and upload (pictures) screenshots to this notebook.\n# 3. **(1 pt.)** Get the classification accuracy for the latest features. Use the `KNN` classifier with any hyperparameters you'll choose. Write a couple of sentences comparing the results of `manifold learning` and ` AE`. \n# 3. **(BONUS 3 pt.)** Sampling from latent representation.\n\n# +\ndef load(f):\n return np.load(f)['arr_0']\n\n# Load the data\nx_train = load('data/kmnist/kmnist-train-imgs.npz')\nx_test = load('data/kmnist/kmnist-test-imgs.npz')\ny_train = load('data/kmnist/kmnist-train-labels.npz')\ny_test = load('data/kmnist/kmnist-test-labels.npz')\n\n# Reshape the data and scale\nx_train = x_train.reshape(-1, 28*28)/255# >>> your solution here <<<\nx_test = x_test.reshape(-1, 28*28)/255# >>> your solution here <<<\n# -\n\nfig, ax = plt.subplots(ncols=10, figsize=(20, 5))\nfor i in range(10):\n ax[i].imshow(x_train[i].reshape(28,28));\n ax[i].axis('off')\n\n\nclass kMNISTData(torch_data.Dataset):\n def __init__(self, X, y):\n super(kMNISTData, self).__init__()\n self.X = torch.tensor(X, dtype=torch.float32) \n self.y = y.astype(int)\n \n def __len__(self):\n return self.X.shape[0]# >>> your solution here <<<\n \n def __getitem__(self, idx):\n return self.X[idx].unsqueeze(0), self.y[idx]# >>> your solution here <<<\n\n\ntrain_kmnist = kMNISTData(x_train, y_train) ### YOUR CODE HERE ###\ntest_kmnist = kMNISTData(x_test, y_test) ### YOUR CODE HERE ###\n\n# #### 2.0 Create encoder and decoder network for kMNIST. \n# You can either use convolutions or flatten the images and use linear layers. You can choose hidden size (not larger than 40) and any architecture you like.\n\nx_train.shape\n\nsample_size = x_train.shape[1]\nss = 128\nencoder = lambda hid: nn.Sequential(\n nn.Linear(sample_size, ss*4),\n nn.LeakyReLU(inplace=True),\n nn.Dropout(0.2),\n nn.Linear(ss*4, ss*2),\n nn.LeakyReLU(inplace=True),\n nn.Dropout(0.2),\n nn.Linear(ss*2, hid)\n )\ndecoder = lambda hid: nn.Sequential(\n nn.Linear(hid, ss*2),\n nn.LeakyReLU(inplace=True),\n nn.Dropout(0.2),\n nn.Linear(ss*2, ss*4),\n nn.LeakyReLU(inplace=True),\n nn.Dropout(0.2),\n nn.Linear(ss*4, sample_size)\n \n ) \n\n\n# #### 2.1 Train AE on the kMNIST. \n# Your goal is to obtain MSE on the test set < $0.035$ on `MyFirstAE(encoder(40), decoder(40))`.\n\n# +\ndevice = 'cpu'\n\nnet = MyFirstAE(encoder(40), decoder(40)) \ncriterion = nn.MSELoss()\noptimizer = torch.optim.Adam(net.parameters(), lr=1e-4)\nscheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=50, gamma=0.7)\n\ntrain_loader = torch_data.DataLoader(train_kmnist, batch_size=128, shuffle=True) \nval_loader = torch_data.DataLoader(test_kmnist, batch_size=128, shuffle=False) \n# -\n\nepochs = 100\ntrain(epochs, net, criterion, optimizer, train_loader, val_loader, scheduler)\n\n# #### 2.2 Plot any 10 images and their reconstructions.\n\nfig, ax = plt.subplots(ncols=10, nrows=2, figsize=(20, 5))\nfor i in range(10):\n im = train_kmnist[i][0]\n rec = net(im.reshape(1, 28*28).to(device))\n ax[0, i].imshow(im[0].reshape(28,28));\n ax[1, i].imshow(rec.detach().numpy().reshape(28,28));\n ax[0, i].axis('off')\n ax[1, i].axis('off')\n\n# #### 2.3 Plot the latent representation of whole dataset in 3D, compare visually to your manifold from `Part 1` and upload (pictures) screenshoots to this notebook.\n\n# +\nfrom mpl_toolkits.mplot3d import Axes3D\nfig = plt.figure(figsize=(20, 20))\nax = Axes3D(fig)\n\ncdict = {0: 'red', 1: 'blue', 2: 'green', 3: 'olive', 4: 'magenta', 5: 'yellow', 6: 'black',\n 7: 'orange', 8: 'pink', 9: 'purple'}\n\ntarget = np.concatenate((train_kmnist[:][1], test_kmnist[:][1]), axis=0)\nall_data = np.concatenate((train_kmnist[:][0][0], test_kmnist[:][0][0]), axis=0)\nrec = net.encoder(torch.from_numpy(all_data)).detach().numpy()\nax.scatter(rec[:, 0], rec[:, 1], rec[:, 2], c=target)\n# -\n\n# PCA_kNN from part 1 3D represenation:\n\n# Autoencoder 3D representation: \n\n# #### 2.4 Get the classification accuracy for the latest features. Use the `KNN` classifier with any hyperparameters you'll choose. Write a couple of sentences comparing the results of `manifold learning` and ` AE`. \n\nd = [rec[i, :] for i in range(rec.shape[0])]\ndf = pd.DataFrame(data=d)\ndf['target'] = target\n\ndatka = df.drop('target', axis=1)\ntarg = df.target\n\n# +\nfrom sklearn.model_selection import cross_val_score, StratifiedKFold\nfrom sklearn.preprocessing import StandardScaler\nfrom sklearn.neighbors import KNeighborsClassifier\ncv_score = []\nsk = StratifiedKFold(n_splits=5)\n\nknn = KNeighborsClassifier(n_neighbors=10, n_jobs=-1)\ncv_score.append(cross_val_score(knn, datka, targ, cv=sk).mean())\nprint('cv accuracy: ', np.max(cv_score))\n# -\n\n# - KNN shown 1.5% higher accuracy compared to the case with PCA from Part 1. Isomap could have shown better results, but it's very computationaly heavy, this is why I used PCA in Part 1. Autoencoder, by the way, is very computationaly light(tooks less than 1 sec to encode-decode on my laptop)\n\n# ### BONUS: Sampling from latent space. (3 points)\n#\n# Imagine, that you want to generate images, using you AE. To do that, you need to sample from the latent space and then decode the result. Of course, we do not know the exact distribution of the latent space. Therefore, let us assume that latent space distribution is Gaussian:\n#\n# * Encode all the training images into the latent space\n# * Calculate mean and covariance matrix ($\\mu$ and $\\Sigma$)\n# * Sample $z$ from the $\\mathcal{N}(\\mu, \\Sigma)$\n# * Decode $z$ from the previous step to obtain an image\n#\n# Using the procedure described above, sample 10 images and plot them (they should be similar to those of the initial dataset)\n\ntarget = train_kmnist[:][1]\nencoded = net.encoder(train_kmnist[:][0][0]).detach().numpy()\n#calc mean\nmean = np.mean(encoded, axis=0)\n#calc cov matrix\ncov = np.cov(encoded.T)\n#draw 10 samples\nsamples = np.random.multivariate_normal(mean, cov, 10)\nfig, ax = plt.subplots(ncols=10, figsize=(20, 5))\nsamples = torch.from_numpy(samples)\n#decode samples\ndecoded = net.decoder(samples.float()).detach().numpy()\nfor i in range(10):\n ax[i].imshow(decoded[i].reshape(28,28));\n ax[i].axis('off')\n\n# **Yeah, so you can get more than `100%` for the homework, good luck!**\n"},"script_size":{"kind":"number","value":25263,"string":"25,263"}}},{"rowIdx":77,"cells":{"path":{"kind":"string","value":"/notebooks/.ipynb_checkpoints/02_practice_exercises-checkpoint.ipynb"},"content_id":{"kind":"string","value":"4a64c4c84754ced3728015437cd7f50594775aa2"},"detected_licenses":{"kind":"list like","value":[],"string":"[]","isConversational":false},"license_type":{"kind":"string","value":"no_license"},"repo_name":{"kind":"string","value":"pcthink11/dw17"},"repo_url":{"kind":"string","value":"https://github.com/pcthink11/dw17"},"star_events_count":{"kind":"number","value":0,"string":"0"},"fork_events_count":{"kind":"number","value":0,"string":"0"},"gha_license_id":{"kind":"null"},"gha_event_created_at":{"kind":"null"},"gha_updated_at":{"kind":"null"},"gha_language":{"kind":"null"},"language":{"kind":"string","value":"Jupyter Notebook"},"is_generated":{"kind":"bool","value":false,"string":"false"},"is_vendor":{"kind":"bool","value":false,"string":"false"},"conversion_extension":{"kind":"string","value":".py"},"size":{"kind":"number","value":85247,"string":"85,247"},"script":{"kind":"string","value":"# ---\n# jupyter:\n# jupytext:\n# text_representation:\n# extension: .py\n# format_name: light\n# format_version: '1.5'\n# jupytext_version: 1.15.2\n# kernelspec:\n# display_name: Python 3\n# language: python\n# name: python3\n# ---\n\n# +\n# author - Richard Liao\n# Dec 26 2016\n# https://richliao.github.io/supervised/classification/2016/11/26/textclassifier-convolutional/\nimport numpy as np\nimport pandas as pd\nimport pickle\nfrom collections import defaultdict\nimport re\n\nfrom bs4 import BeautifulSoup\n\nimport sys\nimport os\n\nos.environ['KERAS_BACKEND']='theano'\n\nfrom keras.preprocessing.text import Tokenizer\nfrom keras.preprocessing.sequence import pad_sequences\nfrom keras.utils.np_utils import to_categorical\n\nfrom keras.layers import Embedding\nfrom keras.layers import Dense, Input, Flatten\nfrom keras.models import Sequential\nfrom keras.layers.core import Activation\nfrom keras.layers import Conv1D, MaxPooling1D, Embedding, Merge, Dropout, Reshape\nfrom keras.models import Model\nfrom keras.models import load_model\nfrom keras.callbacks import EarlyStopping, ModelCheckpoint\nfrom keras.regularizers import l2\n\nimport matplotlib.pyplot as plt\nfrom sklearn import preprocessing\nfrom sklearn.model_selection import train_test_split\n\n\n# fix random seed for reproducibility\nseed = 42\nnp.random.seed(seed)\n\n# %matplotlib inline\n\n# +\nMAX_SEQUENCE_LENGTH = 1000 # top 30\nMAX_NB_WORDS = 20000 # more than vocab size\nEMBEDDING_DIM = 100\nVALIDATION_SPLIT = 0.2\n\n\ndata_train = pd.read_csv('../result_all_windows_labels.csv')\n\n# Cleanup - remove no labels\ndata_train = data_train[data_train['label'].notnull()]\ndata_train = data_train[data_train.label != 'environmental']\ndata_train = data_train[data_train.label != 'religious']\ndata_train = data_train[data_train.label != 'economical']\n\n\nlabel_cat = {'violence/terrorism' : 1, 'misc': 2, 'political': 3, \n# 'religious': 4, 'economical': 5, 'environmental': 6\n }\nprint(label_cat) \n\n\ndef to_category(x):\n return label_cat[x]\n\ndata_train['target'] = data_train.apply(lambda row: to_category(row['label']), axis=1)\n\n\ndata_train['target'].plot.hist(alpha=0.5)\n\n\ntexts = []\n# Get corpus by joining all keywords\nfor index, row in data_train.iloc[ :, 2:32].iterrows():\n texts.append(u' '.join(row.tolist()))\n \ndata_train['topicFlat'] = texts\n\n# texts = datdata_traina_train['topicFlat']\n\nlabels = data_train['target']\n\n# print(labels)\ndata_train['topicFlat'].head()\n\n# +\n# %%time\n \n\ntokenizer = Tokenizer(num_words=MAX_NB_WORDS)\ntokenizer.fit_on_texts(texts)\n\n\n# max_fatures = 10000\n# tokenizer = Tokenizer(num_words=max_fatures, split=' ')\n# tokenizer.fit_on_texts(data_train['topicFlat'].values)\n# X = tokenizer.texts_to_sequences(data_train['topicFlat'].values)\n# X = pad_sequences(X)\n\n# Y = pd.get_dummies(data_train['label']).values\n# x_train, x_test, y_train, y_test = train_test_split(X, Y, test_size = 0.33, random_state = 42)\n\n# print(y_train[100])\n# print(x_train.shape,y_train.shape)\n# print(x_test.shape, y_test.shape)\n\n# print('Number of positive and negative reviews in traing and validation set ')\n# print (y_train.sum(axis=0))\n# print (y_test.sum(axis=0))\n\n# print(X.shape[0])\n\nsequences = tokenizer.texts_to_sequences(texts)\n\n# print(sequences[0])\n# print (max(sequences, key=len))\n\nword_index = tokenizer.word_index\nprint('Found %s unique tokens.' % len(word_index)) # all the tokens in corpus\n# # print(word_index)\n\ndata = pad_sequences(sequences, maxlen=MAX_SEQUENCE_LENGTH)\n# print(data[0])\n\nlabels = to_categorical(np.asarray(labels))\nprint('Shape of data tensor:', data.shape)\nprint('Shape of label tensor:', labels.shape)\n\n# +\nindices = np.arange(data.shape[0])\nnp.random.shuffle(indices)\ndata = data[indices]\nlabels = labels[indices]\nnb_validation_samples = int(VALIDATION_SPLIT * data.shape[0])\n\nx_train = data[:-nb_validation_samples]\ny_train = labels[:-nb_validation_samples]\nx_test = data[-nb_validation_samples:]\ny_test = labels[-nb_validation_samples:]\n\n\nprint('Number of positive and negative reviews in traing and validation set ')\nprint (y_train.sum(axis=0))\nprint (y_test.sum(axis=0))\n\n# +\n# %%time\n\n# https://www.kaggle.com/rtatman/glove-global-vectors-for-word-representation/data\n\nGLOVE_DIR = \"../data/\"\nembeddings_index = {}\nf = open(os.path.join(GLOVE_DIR, 'glove.6B.100d.txt'))\nfor line in f:\n values = line.split()\n word = values[0]\n coefs = np.asarray(values[1:], dtype='float32')\n embeddings_index[word] = coefs\nf.close()\n\nprint('Total %s word vectors in Glove 6B 100d.' % len(embeddings_index))\n\n\n# -\n\ndef plot_history(history):\n # list all data in history\n print(history.history.keys())\n # summarize history for accuracy\n plt.plot(history.history['acc'])\n plt.plot(history.history['val_acc'])\n plt.title('model accuracy')\n plt.ylabel('accuracy')\n plt.xlabel('epoch')\n plt.legend(['train', 'test'], loc='upper left')\n plt.show()\n # summarize history for loss\n plt.plot(history.history['loss'])\n plt.plot(history.history['val_loss'])\n plt.title('model loss')\n plt.ylabel('loss')\n plt.xlabel('epoch')\n plt.legend(['train', 'test'], loc='upper left')\n plt.show()\n\n# +\n# %%time\n\n\nembedding_matrix = np.random.random((len(word_index) + 1, EMBEDDING_DIM))\nfor word, i in word_index.items():\n embedding_vector = embeddings_index.get(word)\n if embedding_vector is not None:\n # words not found in embedding index will be all-zeros.\n embedding_matrix[i] = embedding_vector\n \nembedding_layer = Embedding(len(word_index) + 1,\n EMBEDDING_DIM,\n weights=[embedding_matrix],\n# input_length=MAX_SEQUENCE_LENGTH,\n trainable=True)\n\n\n# Embedding(5000, 32, input_length=500)\n\n# +\n# %%time\n\nepochs=20\n\nsequence_input = Input(shape=(MAX_SEQUENCE_LENGTH,), dtype='int32')\nembedded_sequences = embedding_layer(sequence_input)\nl_cov1= Conv1D(128, 5, activation='relu')(embedded_sequences)\nl_pool1 = MaxPooling1D(5)(l_cov1)\nl_cov2 = Conv1D(128, 5, activation='relu')(l_pool1)\nl_pool2 = MaxPooling1D(5)(l_cov2)\nl_cov3 = Conv1D(128, 5, activation='relu')(l_pool2)\nl_pool3 = MaxPooling1D(35)(l_cov3) # global max pooling\nl_flat = Flatten()(l_pool3)\nl_dense = Dense(128, activation='relu')(l_flat)\npreds = Dense(len(label_cat) + 1, activation='softmax')(l_dense)\n\nmodel = Model(sequence_input, preds)\nmodel.compile(loss='categorical_crossentropy',\n optimizer='adam', metrics=['accuracy'])\n\nprint(\"model fitting - simplified convolutional neural network\")\nmodel.summary()\n\nmodel_name = 'topicConvNet-Reg.h5'\nearly_stop = EarlyStopping(monitor='val_loss', patience=4, verbose=1)\n# best_model = ModelCheckpoint(model_name, verbose=1, save_best_only=True)\n\nbest_model = ModelCheckpoint('weights.{epoch:03d}-{val_acc:.4f}.hdf5', \n monitor='val_acc', verbose=1, save_best_only=True, mode='auto')\n\nnetwork_hist = model.fit(x_train, y_train, validation_data=(x_test, y_test), \n verbose=True, callbacks=[early_stop, best_model], validation_split=0.2,\n epochs=epochs, batch_size=50)\n\nscore, acc = model.evaluate(x_test, y_test, batch_size=50)\nprint('Test score:', score)\nprint('Test accuracy:', acc)\n\n# print(network_hist.history)\nplot_history(network_hist)\n\n\n# +\nfrom IPython.display import SVG\nfrom keras.utils.vis_utils import model_to_dot\n\nSVG(model_to_dot(model).create(prog='dot', format='svg'))\n\n# +\n\n\n\nembedding_matrix = np.random.random((len(word_index) + 1, EMBEDDING_DIM))\nfor word, i in word_index.items():\n embedding_vector = embeddings_index.get(word)\n if embedding_vector is not None:\n # words not found in embedding index will be all-zeros.\n embedding_matrix[i] = embedding_vector\n \nembedding_layer = Embedding(len(word_index) + 1,\n EMBEDDING_DIM,\n weights=[embedding_matrix],\n input_length=MAX_SEQUENCE_LENGTH,\n trainable=True)\n\n# applying a more complex convolutional approach\nconvs = []\nfilter_sizes = [3,4,5]\n\nsequence_input = Input(shape=(MAX_SEQUENCE_LENGTH,), dtype='int32')\nembedded_sequences = embedding_layer(sequence_input)\n\nfor fsz in filter_sizes:\n l_conv = Conv1D(filters=128,filter_length=fsz, activation='relu')(embedded_sequences)\n l_pool = MaxPooling1D(5)(l_conv)\n convs.append(l_pool)\n \nl_merge = Merge(mode='concat', concat_axis=1)(convs)\nl_cov1= Conv1D(filters=128, kernel_size=5, activation='relu')(l_merge)\nl_pool1 = MaxPooling1D(5)(l_cov1)\nl_cov2 = Conv1D(filters=128, kernel_size=5, activation='relu')(l_pool1)\nl_pool2 = MaxPooling1D(30)(l_cov2)\nl_flat = Flatten()(l_pool2)\nl_dense = Dense(128, activation='relu')(l_flat)\npreds = Dense(len(label_cat) + 1, activation='softmax')(l_dense)\n\nmodel = Model(sequence_input, preds)\nmodel.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])\n\nprint(\"model fitting - more complex convolutional neural network\")\nmodel.summary()\n\nmodel_name = 'topicConv_20.h5'\nearly_stop = EarlyStopping(monitor='val_loss', patience=2, verbose=1)\n# best_model = ModelCheckpoint(model_name, verbose=0, save_best_only=True)\n\nbest_model = ModelCheckpoint('weights.{epoch:03d}-{val_acc:.4f}.hdf5', \n monitor='val_acc', verbose=1, save_best_only=True, mode='auto')\n\n\nnetwork_hist = model.fit(x_train, y_train, validation_data=(x_test, y_test), \n verbose=True, callbacks=[early_stop, best_model],\n epochs=20, batch_size=50)\n\nscore, acc = model.evaluate(x_test, y_test, batch_size=50)\nprint('Test score:', score)\nprint('Test accuracy:', acc)\n\n# print(network_hist.history)\nplot_history(network_hist)\n\n# +\n\n# EMBEDDING_DIM = 32\n# embedding_matrix = np.random.random((len(word_index) + 1, EMBEDDING_DIM))\n# for word, i in word_index.items():\n# embedding_vector = embeddings_index.get(word)\n# if embedding_vector is not None:\n# # words not found in embedding index will be all-zeros.\n# embedding_matrix[i] = embedding_vector\n \n# embedding_layer = Embedding(len(word_index) + 1,\n# EMBEDDING_DIM,\n# weights=[embedding_matrix],\n# input_length=MAX_SEQUENCE_LENGTH,\n# trainable=True)\n# create the model\nmodel = Sequential()\nmodel.add(Embedding(len(word_index) + 1, 32, input_length=MAX_SEQUENCE_LENGTH))\nmodel.add(Conv1D(filters=32, kernel_size=3, padding='same', activation='relu'))\nmodel.add(MaxPooling1D(pool_size=2))\nmodel.add(Flatten())\nmodel.add(Dense(250, activation='relu'))\nmodel.add(Dense(len(label_cat) + 1, activation='sigmoid'))\n\nmodel.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])\nprint(model.summary())\n\n\nmodel_name = 'topicConv_simple.h5'\nearly_stop = EarlyStopping(monitor='val_loss', patience=4, verbose=1)\nbest_model = ModelCheckpoint(model_name, verbose=1, save_best_only=True)\n\nnetwork_hist = model.fit(x_train, y_train, validation_data=(x_test, y_test), \n verbose=True, callbacks=[early_stop, best_model],\n epochs=20, batch_size=50)\n\n# Evaluation on the test set\nscore, acc = model.evaluate(x_test, y_test)\nprint(\"Test score: %.2f%%\" % (score*100))\nprint(\"Test accuracy: %.2f%%\" % (acc*100))\n\n# print(network_hist.history)\nplot_history(network_hist)\n\n\n\n\n"},"script_size":{"kind":"number","value":11412,"string":"11,412"}}},{"rowIdx":78,"cells":{"path":{"kind":"string","value":"/COVID_PREDICTION.ipynb"},"content_id":{"kind":"string","value":"f4c7d4dbfafee648d5ce9c32616ca0977dd8b495"},"detected_licenses":{"kind":"list like","value":[],"string":"[]","isConversational":false},"license_type":{"kind":"string","value":"no_license"},"repo_name":{"kind":"string","value":"pd1298/COVID19-PREDICTION"},"repo_url":{"kind":"string","value":"https://github.com/pd1298/COVID19-PREDICTION"},"star_events_count":{"kind":"number","value":0,"string":"0"},"fork_events_count":{"kind":"number","value":0,"string":"0"},"gha_license_id":{"kind":"null"},"gha_event_created_at":{"kind":"null"},"gha_updated_at":{"kind":"null"},"gha_language":{"kind":"null"},"language":{"kind":"string","value":"Jupyter Notebook"},"is_generated":{"kind":"bool","value":false,"string":"false"},"is_vendor":{"kind":"bool","value":false,"string":"false"},"conversion_extension":{"kind":"string","value":".py"},"size":{"kind":"number","value":589233,"string":"589,233"},"script":{"kind":"string","value":"# ---\n# jupyter:\n# jupytext:\n# text_representation:\n# extension: .py\n# format_name: light\n# format_version: '1.5'\n# jupytext_version: 1.15.2\n# kernelspec:\n# display_name: Python 3\n# name: python3\n# ---\n\n# + [markdown] id=\"0ccIvQkU96Zo\" colab_type=\"text\"\n# Importing Important Libraries\n\n# + id=\"D_1LLIDOqNMY\" colab_type=\"code\" colab={\"base_uri\": \"https://localhost:8080/\", \"height\": 74} outputId=\"b746ce2a-0c61-4b3a-d7b9-11d0391dae0b\"\n# importing the required libraries\nimport pandas as pd\n\n# Visualisation libraries\nimport matplotlib.pyplot as plt\n# %matplotlib inline\nimport seaborn as sns\nimport plotly.express as px\nimport plotly.graph_objects as go\nimport folium \nfrom folium import plugins\n\n# Manipulating the default plot size\nplt.rcParams['figure.figsize'] = 10, 12\n\n# Disable warnings \nimport warnings\nwarnings.filterwarnings('ignore')\n\n# + [markdown] id=\"EIHjFFG4IJ_f\" colab_type=\"text\"\n# 1.Reading the Datasets\n\n# + id=\"J6qskKA4qOsd\" colab_type=\"code\" colab={\"base_uri\": \"https://localhost:8080/\", \"height\": 798} outputId=\"849ebf31-4c95-4134-e0da-ed3aea58f0dd\"\n#Reading a .xls file by creating a dataframe using pandas\n# Reading the datasets\ndf= pd.read_excel('/content/drive/My Drive/COVID PREDICTION/Covid cases in India.xlsx')\ndf_india = df.copy()\ndf\n\n# + id=\"zJ_3JfmeqOt_\" colab_type=\"code\" colab={}\n #Coordinates of India States and Union Territories\nIndia_coord = pd.read_excel('/content/drive/My Drive/COVID PREDICTION/Indian Coordinates.xlsx')\n\n#Day by day data of India, Korea, Italy and Wuhan\ndbd_India = pd.read_excel('/content/drive/My Drive/COVID PREDICTION/per_day_cases.xlsx',parse_dates=True, sheet_name='India')\ndbd_Italy = pd.read_excel('/content/drive/My Drive/COVID PREDICTION/per_day_cases.xlsx',parse_dates=True, sheet_name=\"Italy\")\ndbd_Korea = pd.read_excel('/content/drive/My Drive/COVID PREDICTION/per_day_cases.xlsx',parse_dates=True, sheet_name=\"Korea\")\ndbd_Wuhan = pd.read_excel('/content/drive/My Drive/COVID PREDICTION/per_day_cases.xlsx',parse_dates=True, sheet_name=\"Wuhan\")\n\n# + [markdown] id=\"uD1GI1ASIVdK\" colab_type=\"text\"\n# 2. Analysing the COVID19 Dataset\n\n# + id=\"aaz8XFJkqOw2\" colab_type=\"code\" colab={\"base_uri\": \"https://localhost:8080/\", \"height\": 35} outputId=\"a85cfea3-4946-4074-b5c1-b695937019af\"\n\n#Total case is the total number of confirmed cases (Indian National + Foreign National)\n\ndf.drop(['S. No.'],axis=1,inplace=True)\ndf['Total cases'] = df['Total Confirmed cases (Indian National)'] + df['Total Confirmed cases ( Foreign National )']\ntotal_cases = df['Total cases'].sum()\nprint('Total number of confirmed COVID 2019 cases across India till date (22nd March, 2020):', total_cases)\n\n\n# + id=\"A41HRuQ8qOzb\" colab_type=\"code\" colab={\"base_uri\": \"https://localhost:8080/\", \"height\": 563} outputId=\"5930441a-6b3b-444a-c60a-523e1b447ab2\"\n#Learn how to highlight your dataframe\ndf.style.background_gradient(cmap='Reds')\n\n# + [markdown] id=\"rhY6uS-IIjdG\" colab_type=\"text\"\n# 3.Number of Active COVID cases\n\n# + id=\"BkwWaTtis70E\" colab_type=\"code\" colab={\"base_uri\": \"https://localhost:8080/\", \"height\": 602} outputId=\"31a253fb-4ed2-40a2-8cce-f30f1abcf854\"\n#Total Active is the Total cases - (Number of death + Cured)\ndf['Total Active'] = df['Total cases'] - (df['Death'] + df['Cured'])\ntotal_active = df['Total Active'].sum()\nprint('Total number of active COVID 2019 cases across India:', total_active)\nTot_Cases = df.groupby('Name of State / UT')['Total Active'].sum().sort_values(ascending=False).to_frame()\nTot_Cases.style.background_gradient(cmap='Reds')\n\n# + [markdown] id=\"S5BQhEToIrnF\" colab_type=\"text\"\n# 4.Visualising the spread geographically\n\n# + id=\"RnCNIqNZs_6C\" colab_type=\"code\" colab={\"base_uri\": \"https://localhost:8080/\", \"height\": 689} outputId=\"9eb53828-bcd2-409b-acae-422450415504\"\n# Learn how to use folium to create a zoomable map\ndf_full = pd.merge(India_coord,df,on='Name of State / UT')\nmap = folium.Map(location=[20, 70], zoom_start=4,tiles='Stamenterrain')\n\nfor lat, lon, value, name in zip(df_full['Latitude'], df_full['Longitude'], df_full['Total cases'], df_full['Name of State / UT']):\n folium.CircleMarker([lat, lon], radius=value*0.8, popup = ('<strong>State</strong>: ' + str(name).capitalize() + '<br>''<strong>Total Cases</strong>: ' + str(value) + '<br>'),color='red',fill_color='red',fill_opacity=0.3 ).add_to(map)\nmap\n\n# + id=\"K8MaPqFStHck\" colab_type=\"code\" colab={}\n\n\n# + [markdown] id=\"TIKiuvQwI75e\" colab_type=\"text\"\n# Confirmed vs Recovered figures\n\n# + _kg_hide-input=true _kg_hide-output=false id=\"yBavZ1TndhFG\" colab_type=\"code\" colab={\"base_uri\": \"https://localhost:8080/\", \"height\": 497} outputId=\"3fa18b95-0ba1-4c99-bb0d-66ab4992c7c9\"\n#Learn how to use Seaborn for visualization\nf, ax = plt.subplots(figsize=(12, 8))\ndata = df_full[['Name of State / UT','Total cases','Cured','Death']]\ndata.sort_values('Total cases',ascending=False,inplace=True)\nsns.set_color_codes(\"pastel\")\nsns.barplot(x=\"Total cases\", y=\"Name of State / UT\", data=data,label=\"Total\", color=\"r\")\n\nsns.set_color_codes(\"muted\")\nsns.barplot(x=\"Cured\", y=\"Name of State / UT\", data=data, label=\"Cured\", color=\"g\")\n\n\n# Add a legend and informative axis label\nax.legend(ncol=2, loc=\"lower right\", frameon=True)\nax.set(xlim=(0, 35), ylabel=\"\",xlabel=\"Cases\")\nsns.despine(left=True, bottom=True)\n\n# + [markdown] id=\"qNrAEx7iJC26\" colab_type=\"text\"\n# How the Coronavirus cases are rising?\n\n# + id=\"BHFEy_aEtOHs\" colab_type=\"code\" colab={}\n#This cell's code is required when you are working with plotly on colab\nimport plotly\nplotly.io.renderers.default = 'colab'\n\n# + id=\"b_zF2OCmtWls\" colab_type=\"code\" colab={\"base_uri\": \"https://localhost:8080/\", \"height\": 942} outputId=\"8c883f46-e07b-4210-e432-f09ab19f5be8\"\n#Learn how to create interactive graphs using plotly\n# import plotly.graph_objects as go\n# Rise of COVID-19 cases in India\nfig = go.Figure()\nfig.add_trace(go.Scatter(x=dbd_India['Date'], y = dbd_India['Total Cases'], mode='lines+markers',name='Total Cases'))\nfig.update_layout(title_text='Trend of Coronavirus Cases in India (Cumulative cases)',plot_bgcolor='rgb(230, 230, 230)')\nfig.show()\n\n# New COVID-19 cases reported daily in India\n\nimport plotly.express as px\nfig = px.bar(dbd_India, x=\"Date\", y=\"New Cases\", barmode='group', height=400)\nfig.update_layout(title_text='Coronavirus Cases in India on daily basis',plot_bgcolor='rgb(230, 230, 230)')\n\nfig.show()\n\n# + [markdown] id=\"fIEIDFQVJJSG\" colab_type=\"text\"\n# Cumulative cases in India, Italy, S.Korea, and Wuhan\n\n# + id=\"TI0VxFsztZKi\" colab_type=\"code\" colab={\"base_uri\": \"https://localhost:8080/\", \"height\": 1000} outputId=\"7da833d5-7b5b-4753-8b06-89cbf3edfcfd\"\n# import plotly.express as px\nfig = px.bar(dbd_India, x=\"Date\", y=\"Total Cases\", color='Total Cases', orientation='v', height=600,\n title='Confirmed Cases in India', color_discrete_sequence = px.colors.cyclical.IceFire)\n\n'''Colour Scale for plotly\nhttps://plot.ly/python/builtin-colorscales/\n'''\n\nfig.update_layout(plot_bgcolor='rgb(230, 230, 230)')\nfig.show()\n\nfig = px.bar(dbd_Italy, x=\"Date\", y=\"Total Cases\", color='Total Cases', orientation='v', height=600,\n title='Confirmed Cases in Italy', color_discrete_sequence = px.colors.cyclical.IceFire)\n\nfig.update_layout(plot_bgcolor='rgb(230, 230, 230)')\nfig.show()\n\nfig = px.bar(dbd_Korea, x=\"Date\", y=\"Total Cases\", color='Total Cases', orientation='v', height=600,\n title='Confirmed Cases in South Korea', color_discrete_sequence = px.colors.cyclical.IceFire)\n\nfig.update_layout(plot_bgcolor='rgb(230, 230, 230)')\nfig.show()\nfig = px.bar(dbd_Wuhan, x=\"Date\", y=\"Total Cases\", color='Total Cases', orientation='v', height=600,\n title='Confirmed Cases in Wuhan', color_discrete_sequence = px.colors.cyclical.IceFire)\n\nfig.update_layout(plot_bgcolor='rgb(230, 230, 230)')\nfig.show()\n\n# + [markdown] id=\"nFIXjOaJJU8g\" colab_type=\"text\"\n# Comparison between the rise of cases in Wuhan, S.Korea, Italy and India\n\n# + id=\"dvz3B2NWtoH1\" colab_type=\"code\" colab={\"base_uri\": \"https://localhost:8080/\", \"height\": 542} outputId=\"548de806-0c45-4bd6-95a2-bf6203cf83ce\"\n#Learn how to create subplots using plotly\n# import plotly.graph_objects as go\nfrom plotly.subplots import make_subplots\n\nfig = make_subplots(\n rows=2, cols=2,\n specs=[[{}, {}],\n [{\"colspan\": 2}, None]],\n subplot_titles=(\"S.Korea\",\"Italy\", \"India\",\"Wuhan\"))\n\nfig.add_trace(go.Bar(x=dbd_Korea['Date'], y=dbd_Korea['Total Cases'],\n marker=dict(color=dbd_Korea['Total Cases'], coloraxis=\"coloraxis\")),1, 1)\n\nfig.add_trace(go.Bar(x=dbd_Italy['Date'], y=dbd_Italy['Total Cases'],\n marker=dict(color=dbd_Italy['Total Cases'], coloraxis=\"coloraxis\")),1, 2)\n\nfig.add_trace(go.Bar(x=dbd_India['Date'], y=dbd_India['Total Cases'],\n marker=dict(color=dbd_India['Total Cases'], coloraxis=\"coloraxis\")),2, 1)\n\n# fig.add_trace(go.Bar(x=dbd_Wuhan['Date'], y=dbd_Wuhan['Total Cases'],\n# marker=dict(color=dbd_Wuhan['Total Cases'], coloraxis=\"coloraxis\")),2, 2)\n\nfig.update_layout(coloraxis=dict(colorscale='Bluered_r'), showlegend=False,title_text=\"Total Confirmed cases(Cumulative)\")\n\nfig.update_layout(plot_bgcolor='rgb(230, 230, 230)')\nfig.show()\n\n# + [markdown] id=\"g2BFZokAJa60\" colab_type=\"text\"\n# Trend after crossing 100 cases\n\n# + id=\"NTAw6OlDtvgF\" colab_type=\"code\" colab={\"base_uri\": \"https://localhost:8080/\", \"height\": 542} outputId=\"2b2954d5-7da2-4cd2-b3fe-c7998645538e\"\n# import plotly.graph_objects as go\n\ntitle = 'Main Source for News'\nlabels = ['S.Korea', 'Italy', 'India']\ncolors = ['rgb(122,128,0)', 'rgb(255,0,0)', 'rgb(49,130,189)']\n\nmode_size = [10, 10, 12]\nline_size = [1, 1, 8]\n\nfig = go.Figure()\n\n\nfig.add_trace(go.Scatter(x=dbd_Korea['Days after surpassing 100 cases'], \n y=dbd_Korea['Total Cases'],mode='lines',\n name=labels[0],\n line=dict(color=colors[0], width=line_size[0]), \n connectgaps=True))\nfig.add_trace(go.Scatter(x=dbd_Italy['Days after surpassing 100 cases'], \n y=dbd_Italy['Total Cases'],mode='lines',\n name=labels[1],\n line=dict(color=colors[1], width=line_size[1]), \n connectgaps=True))\n\nfig.add_trace(go.Scatter(x=dbd_India['Days after surpassing 100 cases'], \n y=dbd_India['Total Cases'],mode='lines',\n name=labels[2],\n line=dict(color=colors[2], width=line_size[2]), \n connectgaps=True))\n \n \n \nannotations = []\n\nannotations.append(dict(xref='paper', yref='paper', x=0.5, y=-0.1,\n xanchor='center', yanchor='top',\n text='Days after crossing 100 cases ',\n font=dict(family='Arial',\n size=12,\n color='rgb(150,150,150)'),\n showarrow=False))\n\nfig.update_layout(annotations=annotations,plot_bgcolor='white',yaxis_title='Cumulative cases')\n\nfig.show()\n\n# + [markdown] id=\"O1IbAQtXJn1k\" colab_type=\"text\"\n# Exploring Worldwide Data\n\n# + id=\"pNxVqcmxJhtD\" colab_type=\"code\" colab={}\ndf = pd.read_csv('/content/drive/My Drive/COVID PREDICTION/covid_19_clean_complete.csv',parse_dates=['Date'])\ndf.rename(columns={'ObservationDate':'Date', 'Country/Region':'Country'}, inplace=True)\n\ndf_confirmed = pd.read_csv(\"/content/drive/My Drive/COVID PREDICTION/time_series_covid19_confirmed_global.csv\")\ndf_recovered = pd.read_csv(\"/content/drive/My Drive/COVID PREDICTION/time_series_covid19_recovered_global.csv\")\ndf_deaths = pd.read_csv(\"/content/drive/My Drive/COVID PREDICTION/time_series_covid19_deaths_global.csv\")\n\ndf_confirmed.rename(columns={'Country/Region':'Country'}, inplace=True)\ndf_recovered.rename(columns={'Country/Region':'Country'}, inplace=True)\ndf_deaths.rename(columns={'Country/Region':'Country'}, inplace=True)\n\n# + id=\"eUQ33IqWJhu1\" colab_type=\"code\" colab={\"base_uri\": \"https://localhost:8080/\", \"height\": 218} outputId=\"04f37b7b-c390-47be-caf0-504a1b00f20c\"\ndf_deaths.head()\n\n# + id=\"MmWi0AD3Jhyi\" colab_type=\"code\" colab={\"base_uri\": \"https://localhost:8080/\", \"height\": 198} outputId=\"d5327df5-baa7-47e2-b8fe-528b530c3fb0\"\ndf.head()\n\n# + id=\"GrsFnRhmJh1C\" colab_type=\"code\" colab={\"base_uri\": \"https://localhost:8080/\", \"height\": 198} outputId=\"7eb2420f-012f-460c-cbba-9b4ec61e94e0\"\ndf2 = df.groupby([\"Date\", \"Country\", \"Province/State\"])[['Date', 'Province/State', 'Country', 'Confirmed', 'Deaths', 'Recovered']].sum().reset_index()\ndf2.head()\n\n# + id=\"m--6Wlc5Jh5f\" colab_type=\"code\" colab={\"base_uri\": \"https://localhost:8080/\", \"height\": 407} outputId=\"2000811c-4b58-4fcc-b566-b56b76407c30\"\n# Check for India's data\ndf.query('Country==\"India\"').groupby(\"Date\")[['Confirmed', 'Deaths', 'Recovered']].sum().reset_index()\n\n# + id=\"vuzDu_lcJh9V\" colab_type=\"code\" colab={\"base_uri\": \"https://localhost:8080/\", \"height\": 228} outputId=\"9ae90054-5e7a-4add-817f-07788ef9e7a2\"\n#Overall worldwide Confirmed/ Deaths/ Recovered cases \ndf.groupby('Date').sum().head()\n\n# + [markdown] id=\"T6utDl93KFPY\" colab_type=\"text\"\n# Visualizing WorldWide COVID19 Data\n\n# + id=\"-ubMuxdjJh4d\" colab_type=\"code\" colab={}\nconfirmed = df.groupby('Date').sum()['Confirmed'].reset_index()\ndeaths = df.groupby('Date').sum()['Deaths'].reset_index()\nrecovered = df.groupby('Date').sum()['Recovered'].reset_index()\n\n# + id=\"q1VV-RAqKLdw\" colab_type=\"code\" colab={\"base_uri\": \"https://localhost:8080/\", \"height\": 542} outputId=\"395430dd-d314-4257-d6cb-7dc725c6f0c0\"\nfig = go.Figure()\n#Plotting datewise confirmed cases\nfig.add_trace(go.Scatter(x=confirmed['Date'], y=confirmed['Confirmed'], mode='lines+markers', name='Confirmed',line=dict(color='blue', width=2)))\nfig.add_trace(go.Scatter(x=deaths['Date'], y=deaths['Deaths'], mode='lines+markers', name='Deaths', line=dict(color='Red', width=2)))\nfig.add_trace(go.Scatter(x=recovered['Date'], y=recovered['Recovered'], mode='lines+markers', name='Recovered', line=dict(color='Green', width=2)))\nfig.update_layout(title='Worldwide NCOVID-19 Cases', xaxis_tickfont_size=14,yaxis=dict(title='Number of Cases'))\n\nfig.show()\n\n# + [markdown] id=\"XlcgJaqFRzGY\" colab_type=\"text\"\n# Forecasting Total Number of Cases Worldwide\n\n# + id=\"Bbed4Qx3J-zm\" colab_type=\"code\" colab={}\nfrom fbprophet import Prophet\n\n# + id=\"ooUbGfROKUs5\" colab_type=\"code\" colab={}\nconfirmed = df.groupby('Date').sum()['Confirmed'].reset_index()\ndeaths = df.groupby('Date').sum()['Deaths'].reset_index()\nrecovered = df.groupby('Date').sum()['Recovered'].reset_index()\n\n# + id=\"j0YPW3tdKUuv\" colab_type=\"code\" colab={}\nconfirmed.columns = ['ds','y']\n#confirmed['ds'] = confirmed['ds'].dt.date\nconfirmed['ds'] = pd.to_datetime(confirmed['ds'])\n\n# + id=\"sP_kO33HKUyl\" colab_type=\"code\" colab={\"base_uri\": \"https://localhost:8080/\", \"height\": 198} outputId=\"eef8a17c-c065-4c17-e1fb-0cb0f0833846\"\nconfirmed.tail()\n\n# + [markdown] id=\"5mS_QGZRSJen\" colab_type=\"text\"\n# Forecasting Confirmed NCOVID-19 Cases Worldwide with Prophet (Base model)\n\n# + id=\"qJsbYoFHKU8Y\" colab_type=\"code\" colab={\"base_uri\": \"https://localhost:8080/\", \"height\": 235} outputId=\"abe2e5ec-12cc-4777-844e-f8b2500039af\"\nm = Prophet(interval_width=0.95)\nm.fit(confirmed)\nfuture = m.make_future_dataframe(periods=7)\nfuture.tail()\n\n# + id=\"GRxD893LNygg\" colab_type=\"code\" colab={\"base_uri\": \"https://localhost:8080/\", \"height\": 198} outputId=\"3c005358-b9c8-4bac-bf55-901b149b06b5\"\n#predicting the future with date, and upper and lower limit of y value\nforecast = m.predict(future)\nforecast[['ds', 'yhat', 'yhat_lower', 'yhat_upper']].tail()\n\n# + id=\"yU148IqyNyjW\" colab_type=\"code\" colab={\"base_uri\": \"https://localhost:8080/\", \"height\": 441} outputId=\"f61515ff-7825-46bc-c549-af0c7e7fe33d\"\nconfirmed_forecast_plot = m.plot(forecast)\n\n# + id=\"ncY09iBSNytM\" colab_type=\"code\" colab={\"base_uri\": \"https://localhost:8080/\", \"height\": 441} outputId=\"0326ca99-71bf-4e99-8cd3-a5ca6c5423d1\"\nconfirmed_forecast_plot =m.plot_components(forecast)\n\n# + [markdown] id=\"Zrr6ouyBSYKS\" colab_type=\"text\"\n# Forecasting Worldwide Deaths using Prophet (Base model)\n\n# + id=\"YfX-slcqN9Wc\" colab_type=\"code\" colab={}\ndeaths.columns = ['ds','y']\ndeaths['ds'] = pd.to_datetime(deaths['ds'])\n\n# + id=\"44gtwzIUN9fT\" colab_type=\"code\" colab={\"base_uri\": \"https://localhost:8080/\", \"height\": 235} outputId=\"8e7ad307-8e6c-44d9-c421-8862abdb4d84\"\nm = Prophet(interval_width=0.95)\nm.fit(deaths)\nfuture = m.make_future_dataframe(periods=7)\nfuture.tail()\n\n# + id=\"l8KjTIMON9hZ\" colab_type=\"code\" colab={\"base_uri\": \"https://localhost:8080/\", \"height\": 198} outputId=\"339c5e80-d084-4d71-bd3e-b78449496a36\"\nforecast = m.predict(future)\nforecast[['ds', 'yhat', 'yhat_lower', 'yhat_upper']].tail()\n\n# + id=\"smWg4xKYN9kx\" colab_type=\"code\" colab={\"base_uri\": \"https://localhost:8080/\", \"height\": 441} outputId=\"a16d14f0-6ebf-4040-c567-aa850060ecc1\"\ndeaths_forecast_plot = m.plot(forecast)\n\n# + id=\"f1HQPZoGONdM\" colab_type=\"code\" colab={\"base_uri\": \"https://localhost:8080/\", \"height\": 441} outputId=\"af88cd66-6802-48f4-f7b7-6e9f7a4cd49d\"\ndeaths_forecast_plot = m.plot_components(forecast)\n\n# + [markdown] id=\"IpraBCZLShX7\" colab_type=\"text\"\n# Forecasting Worldwide Recovered Cases with Prophet (Base model)\n\n# + id=\"DISne1aCOTGY\" colab_type=\"code\" colab={}\nrecovered.columns = ['ds','y']\nrecovered['ds'] = pd.to_datetime(recovered['ds'])\n\n# + id=\"1MLongLsOTQe\" colab_type=\"code\" colab={\"base_uri\": \"https://localhost:8080/\", \"height\": 235} outputId=\"69a01bd4-5c27-481a-832d-d5e508b2c70c\"\nm = Prophet(interval_width=0.95)\nm.fit(recovered)\nfuture = m.make_future_dataframe(periods=7)\nfuture.tail()\n\n# + id=\"TRnCAQi0OTTb\" colab_type=\"code\" colab={\"base_uri\": \"https://localhost:8080/\", \"height\": 198} outputId=\"377c9a17-3055-4699-961a-0d28a2e7f930\"\nforecast = m.predict(future)\nforecast[['ds', 'yhat', 'yhat_lower', 'yhat_upper']].tail()\n\n# + id=\"bA06VpJoOacE\" colab_type=\"code\" colab={\"base_uri\": \"https://localhost:8080/\", \"height\": 441} outputId=\"910390d8-4eaa-4c31-be19-309f7a714ca6\"\nrecovered_forecast_plot = m.plot(forecast)\n\n# + id=\"XNX_NhSBOamZ\" colab_type=\"code\" colab={\"base_uri\": \"https://localhost:8080/\", \"height\": 441} outputId=\"1af013d8-9f3c-4ef8-ca7d-c3796be56059\"\nrecovered_forecast_plot = m.plot_components(forecast)\n"},"script_size":{"kind":"number","value":18322,"string":"18,322"}}},{"rowIdx":79,"cells":{"path":{"kind":"string","value":"/09_Youtube_Data_Analysis/UseCase_9.ipynb"},"content_id":{"kind":"string","value":"63a5f6b00ea1f86fd2350ae45ed473a06485fbc8"},"detected_licenses":{"kind":"list like","value":[],"string":"[]","isConversational":false},"license_type":{"kind":"string","value":"no_license"},"repo_name":{"kind":"string","value":"VarunCK25/UseCases_PySpark"},"repo_url":{"kind":"string","value":"https://github.com/VarunCK25/UseCases_PySpark"},"star_events_count":{"kind":"number","value":0,"string":"0"},"fork_events_count":{"kind":"number","value":0,"string":"0"},"gha_license_id":{"kind":"null"},"gha_event_created_at":{"kind":"null"},"gha_updated_at":{"kind":"null"},"gha_language":{"kind":"null"},"language":{"kind":"string","value":"Jupyter Notebook"},"is_generated":{"kind":"bool","value":false,"string":"false"},"is_vendor":{"kind":"bool","value":false,"string":"false"},"conversion_extension":{"kind":"string","value":".py"},"size":{"kind":"number","value":10292,"string":"10,292"},"script":{"kind":"string","value":"# ---\n# jupyter:\n# jupytext:\n# text_representation:\n# extension: .py\n# format_name: light\n# format_version: '1.5'\n# jupytext_version: 1.15.2\n# kernelspec:\n# display_name: Python 3\n# language: python\n# name: python3\n# ---\n\n# # Youtube Data Analysis\n\n# This usecase is about analyzing the data of YouTube. This total analysis is performed using Apache Spark. This YouTube data is publicly available and the data set is described below under the heading Data Set Description.\n# Using that dataset, we will perform some analysis and will draw out some insights, like what are the top 10 rated videos in YouTube and who uploaded the most number of videos.\n\n# **Data Set Description**\n#\n# - **Column 1:** Video id of 11 characters.\n#\n# - **Column 2:** Uploader of the video.\n#\n# - **Column 3:** Interval between day of establishment of YouTube and the date of uploading of the video.\n#\n# - **Column 4:** Category of the video.\n#\n# - **Column 5:** Length of the video.\n#\n# - **Column 6:** Number of views for the video.\n#\n# - **Column 7:** Rating on the video.\n#\n# - **Column 8:** Number of ratings given for the video\n#\n# - **Column 9:** Number of comments on the videos.\n#\n# - **Column 10:** Related video ids with the uploaded video.\n\n# ## Initializing spark session\n\nimport findspark\nfindspark.init()\nimport pyspark\n\nfrom pyspark.sql import SparkSession\n\nspark = SparkSession.builder.appName('usecase_9').getOrCreate()\nsc = spark.sparkContext\nsc.setLogLevel('ERROR')\n\n\n\n# ### YouTube Data\n\nyoutube_df = spark.read.format('csv').options(header=False, inferSchema=True, delimiter='\\t').load('youtubedata.txt')\n\nyoutube_df.count()\n\nyoutube_df.printSchema()\n\nyoutube_df.show(3)\n\nfrom pyspark.sql.functions import desc\n\n\n\n# ### Problem Statement 1: Find out what are the top five categories with maximum number of videos uploaded.\n\nyoutube_df = youtube_df.withColumnRenamed('_c3','category')\n\nyoutube_df.groupBy('category').count().orderBy(desc('count')).show(5)\n\n\n\n# ### Problem Statement 2: Find the top 10 rated videos in YouTube.\n\nyoutube_df = youtube_df.withColumnRenamed('_c0','video_id').withColumnRenamed('_c6','Rating')\n\nyoutube_df.select('video_id','rating').show(3)\n\nyoutube_df.groupBy('video_id').agg({'Rating':'sum'}).orderBy(desc('sum(Rating)')).show(10)\n\n\n\n# ## Closing Spark Session\n\nspark.stop()\n"},"script_size":{"kind":"number","value":2349,"string":"2,349"}}},{"rowIdx":80,"cells":{"path":{"kind":"string","value":"/Uber.ipynb"},"content_id":{"kind":"string","value":"b6a09901424616baac308575dfc41ff8d0f0e048"},"detected_licenses":{"kind":"list like","value":[],"string":"[]","isConversational":false},"license_type":{"kind":"string","value":"no_license"},"repo_name":{"kind":"string","value":"ScottSmith59/Driving"},"repo_url":{"kind":"string","value":"https://github.com/ScottSmith59/Driving"},"star_events_count":{"kind":"number","value":0,"string":"0"},"fork_events_count":{"kind":"number","value":0,"string":"0"},"gha_license_id":{"kind":"null"},"gha_event_created_at":{"kind":"null"},"gha_updated_at":{"kind":"null"},"gha_language":{"kind":"null"},"language":{"kind":"string","value":"Jupyter Notebook"},"is_generated":{"kind":"bool","value":false,"string":"false"},"is_vendor":{"kind":"bool","value":false,"string":"false"},"conversion_extension":{"kind":"string","value":".py"},"size":{"kind":"number","value":304717,"string":"304,717"},"script":{"kind":"string","value":"# ---\n# jupyter:\n# jupytext:\n# text_representation:\n# extension: .py\n# format_name: light\n# format_version: '1.5'\n# jupytext_version: 1.15.2\n# kernelspec:\n# display_name: Python 3\n# language: python\n# name: python3\n# ---\n\n# +\nimport pandas as pd\nimport numpy as np\nfrom datetime import datetime\n\ndf_uber = pd.read_csv('Uber.csv')\n# -\n\ndf_uber.head()\n\ndf_uber.shape\n\ndf_uber.info()\n\ndf_uber.describe()\n\ndf_uber_clean = df_uber.copy()\n\ndf_uber_clean\n\ndf_uber_clean = df_uber_clean.drop('Time.1', axis=1)\n\n# +\n#df_uber_clean['Time']= pd.to_datetime(df_uber_clean['Time'])\n# -\n\ndf_uber_clean.head()\n\ndf_uber_clean = df_uber_clean.drop('Unnamed: 5', axis=1)\n\ndf_uber_clean = df_uber_clean.drop('Total', axis=1)\n\ndf_uber_clean.head()\n\ndf_uber_clean.Miles = df_uber_clean.Miles.str[:-3]\n\ndf_uber_clean.tail()\n\ndf_uber_clean.Miles = df_uber_clean.Miles.astype(float)\n\ndf_uber_clean.at[912, \"Cost\"] = '$7.67'\n\ndf_uber_clean.info()\n\ndf_uber_clean['Day'], df_uber_clean['Dates'] = df_uber_clean['Date'].str.split(' ', 1).str\n\ndf_uber_clean.head()\n\ndf_uber_clean = df_uber_clean.drop('Date', axis=1)\n\ndf_uber_clean.head()\n\ndf_uber_clean = df_uber_clean[['Day', 'Dates', 'Time', 'Miles', 'Cost', 'Beginning Route', 'End Route']]\n\ndf_uber_clean.Cost = df_uber_clean.Cost.str[1:]\n\ndf_uber_clean.head()\n\ndf_uber_clean.Cost = df_uber_clean.Cost.astype(float)\n\ndf_uber_clean.info()\n\ndf_uber_clean['WkDay'] = df_uber_clean['Day'].str[:3]\n\ndf_uber_clean.head()\n\ndf_uber_clean = df_uber_clean.drop('Day', axis=1)\n\ndf_uber_clean.head()\n\ndf_uber_clean = df_uber_clean[['WkDay', 'Dates', 'Time', 'Miles', 'Cost', 'Beginning Route', 'End Route']]\n\ndf_uber_clean.head()\n\n# +\n#df_uber_clean.loc[df_uber_clean['Beginning Route'].isna(), 'Beginning Route'] == 'none'\n#df_uber_clean.loc[df_uber_clean['Beginning Route'] == '', 'Beginning Route'] = df_uber_clean.loc[df_uber_clean['Beginning Route'] == '', 'Beginning Route'].fillna('none')\n# -\n\ndf_uber_clean.mean()\n\ndf_day = df_uber_clean.groupby(['WkDay'], as_index = False)['Cost'].mean()\n#df_day = df_uber_clean.groupby(['WkDay', \"Time\"], as_index = False)['Cost'].mean()\n\ndf_day\n\ndf_day[['WkDay'] == 'Fri'].mean()\n\ndf_time_m = df_uber_clean[df_uber_clean['Time'] <= 1000]\n\ndf_time_m\n\nmask = df_uber_clean['Time'] <= 1000\ndf_time_m = df_uber_clean[mask]\ndf_time_m\n\ndf_time_m.Cost.mean()\n\ndf_time_m.WkDay.value_counts()\n\ndf_time_m['Dates'].describe()\n\ndf_time_a = df_uber_clean[df_uber_clean['Time'] > 1400]\n\nmask = df_uber_clean['Time'] > 1400\ndf_time_a = df_uber_clean[mask]\ndf_time_a\n\ndf_time_a.Cost.mean()\n\ndf_time_a.WkDay.value_counts()\n\ndf_time_l = df_uber_clean[(df_uber_clean.Time > 1000) & (df_uber_clean.Time <= 1400)]\n\ndf_time_l\n\ndf_time_l.Cost.mean()\n\ndf_time_mor = df_uber_clean.query('Time < 1000')\n\ndf_time_mor\n\ndf_time_mor.Cost.mean()\n\ndf_time_aft = df_uber_clean.query('Time > 1400')\n\ndf_time_aft\n\ndf_time_aft.Cost.mean()\n\ndf_time_lun = df_uber_clean.query('Time > 1000 & Time <= 1400')\n\ndf_time_lun\n\ndf_time_lun.Cost.mean()\n\n\n"},"script_size":{"kind":"number","value":3011,"string":"3,011"}}},{"rowIdx":81,"cells":{"path":{"kind":"string","value":"/dataset creation using beautifulsoup.ipynb"},"content_id":{"kind":"string","value":"18f2ea8b42b3e1c4b466a3d94080a076c3e19b68"},"detected_licenses":{"kind":"list like","value":["MIT"],"string":"[\n \"MIT\"\n]","isConversational":false},"license_type":{"kind":"string","value":"permissive"},"repo_name":{"kind":"string","value":"ranjankoirala1998/predict-box-office-revenue-with-simple-linear-regression"},"repo_url":{"kind":"string","value":"https://github.com/ranjankoirala1998/predict-box-office-revenue-with-simple-linear-regression"},"star_events_count":{"kind":"number","value":0,"string":"0"},"fork_events_count":{"kind":"number","value":0,"string":"0"},"gha_license_id":{"kind":"null"},"gha_event_created_at":{"kind":"null"},"gha_updated_at":{"kind":"null"},"gha_language":{"kind":"null"},"language":{"kind":"string","value":"Jupyter Notebook"},"is_generated":{"kind":"bool","value":false,"string":"false"},"is_vendor":{"kind":"bool","value":false,"string":"false"},"conversion_extension":{"kind":"string","value":".py"},"size":{"kind":"number","value":3106,"string":"3,106"},"script":{"kind":"string","value":"# ---\n# jupyter:\n# jupytext:\n# text_representation:\n# extension: .py\n# format_name: light\n# format_version: '1.5'\n# jupytext_version: 1.15.2\n# kernelspec:\n# display_name: Python 3\n# language: python\n# name: python3\n# ---\n\n#Import necessary Libraries\nimport numpy as np\nimport pandas as pd\nimport matplotlib.pyplot as plt\nimport seaborn as sns\n# %matplotlib inline\n\n# #### Load the dataframe into pandas dataframe\n\ndata=pd.read_csv(\"insurance.csv\")\ndata\n\n#shape of the data\ndata.shape\n\n# So, there are 1338 observations and 7 columns are available in the dataset.\n\ndata.duplicated().sum()\n\ndata=data.drop_duplicates()\n\n\n#Datatype of Attributes\ndata.dtypes\n\n#Checking missing values\ndata.isnull().values.any()\n\n# shows True==> if any missing values is there.\n#\n# False==> if any missing values is not there.\n# \n# Here, Dataset has no missing Values.\n\n# it gives total number of non null entries in the dataframe\ndata.isnull().sum()\n\n#5 point summary of numerical attributes\ndes_data=data.describe().T\ndes_data\n\n# Distribution of bmi,age, charges columns.\ndata1=data[[\"bmi\",\"age\",\"charges\"]]\nsns.pairplot( data1)\n\nsns.distplot(data1[\"bmi\"])\n\n# The curve shows the density plot which is a smooth version of the histogram. The y-axis is in terms of density and the histogram is normalized by default.\n\nplt.figure(figsize = (12,8))\ncnt=sns.countplot(x=\"age\",data=data1)\ncnt.set_title(\"Different age groups:\",fontsize=20)\n\n\nsns.boxplot(\"charges\",data=data1)\n\n# The shape of the charges is right skewed Distribution.\n\ncorr=data1.corr()\ncorr\n\nsns.heatmap(corr)\n\n# The above correlation value informs that there is a comparatively strong relationship exists between age & charges.\n\nsns.scatterplot(x=data1['bmi'], y=data1['charges'])\n\n# The scatterplot above suggests that body mass index (BMI) and charges are positively correlated.\n\n#Measure of skewness of ‘bmi’, ‘age’ and ‘charges’ columns\ndata1.skew()\n\n# When, Skewness=0 ==>normal distribution\n#\n# Skewness>0 ==>positively skewed distribution/Right skewed Distribution. (has a long right tail).\n# \n# Skewness<0==>negatively skewed distribution/Left skewed Distribution. (has a long left tail).\n#\n# We have al positive values that means the shape of \"bmi\",\"age\",\"charges\" are right skewed.\n\n# +\n#Checking the presence of outliers in ‘bmi’, ‘age’ and ‘charges columns.\noutliers=[]\ndef find_outliers(data):\n sorted_data=sorted(data)\n q1,q3=np.percentile(sorted_data,[25,75])\n iqr=q3-q1\n min=q1-1.5*iqr\n max=q3+1.5*iqr\n for i in data:\n if i<min or i>max:\n outliers.append(i)\n print(\"The number of outliers present are:\",len(outliers))\nbmi=data1[\"bmi\"]\nage=data1[\"age\"]\ncharges=data1[\"charges\"]\nfind_outliers(bmi)\n\n\n# -\n\nsns.boxplot(data1[\"bmi\"])\n\nsns.boxplot(data1[\"age\"])\n\nsns.boxplot(data1[\"charges\"])\n\n#Distribution of categorical column.\ndata_cat=data[[\"sex\",\"smoker\",\"region\",\"children\"]]\ndata_cat\n\ndata_cat[\"smoker\"].count()\n\ndata_cat[\"smoker\"].value_counts()\n\nsns.countplot(\"smoker\",data=data_cat)\n\ndata_cat[\"sex\"].value_counts()\n\nsns.countplot(x=\"smoker\",hue=\"sex\",data=data_cat)\n\npd.pivot_table(data_cat,index=[\"region\",\"sex\"],columns=[\"smoker\"],aggfunc=len)\n\n#Pair plot that includes all the columns of the data frame.\nsns.pairplot(data)\n\nsns.pairplot(data=data,hue='sex')\n\nsns.pairplot(data=data,hue='smoker')\n\nsns.pairplot(data=data,hue='region')\n\nsns.scatterplot(x=data[\"bmi\"], y=data[\"charges\"], hue=data[\"smoker\"])\n\nsns.swarmplot(x=data[\"smoker\"],y=data[\"charges\"])\n\n# This above plot shows that smokers billing amount is more than the non-smoker.\n\n# #### Do charges of people who smoke differ significantly from the people who don't ?\n\nimport scipy.stats as stats\n\n# +\nHo=\"Charges of smoker and non-smoker are same\" #Null hypothesis\n\nHa=\"charges of smoker and non-smoker are not same\" #Alternative hypothesis\n# -\n\nx=np.array(data[data[\"smoker\"]==\"yes\"].charges)\ny=np.array(data[data[\"smoker\"]==\"no\"].charges)\n\n# +\nt_stat,p_value=stats.ttest_ind(x,y,axis=0)\n\nt_stat,p_value\n# -\n\n#significant level=0.05\nif p_value<0.05:\n print(Ha)\nelse:\n print(Ho)\n \n\n# #### Does bmi of males differ significantly from that of females?\n\n# +\nHo=\"bmi of male and female are same\" #Null hypothesis\n\nHa=\"bmi of male and female are not same\" #Alternative hypothesis\n# -\n\nx=np.array(data[data[\"sex\"]==\"male\"].bmi)\ny=np.array(data[data[\"sex\"]==\"female\"].bmi)\n\n# +\nt_stat,p_value=stats.ttest_ind(x,y,axis=0)\n\nt_stat,p_value\n# -\n\n#significant level=0.05\nif p_value<0.05:\n print(Ha)\nelse:\n print(Ho)\n\n\n `key in di` will return `True` if _di_ has a key _key_, else `False`. \n#\n# The dictionary `vocab` will utilize these features.\n\n# +\n# load in the training corpus\nwith open(\"WSJ_02-21.pos\", 'r') as f:\n training_corpus = f.readlines()\n\nprint(f\"A few items of the training corpus list\")\nprint(training_corpus[0:5])\n\n# +\n# read the vocabulary data, split by each line of text, and save the list\nwith open(\"hmm_vocab.txt\", 'r') as f:\n voc_l = f.read().split('\\n')\n\nprint(\"A few items of the vocabulary list\")\nprint(voc_l[0:50])\nprint()\nprint(\"A few items at the end of the vocabulary list\")\nprint(voc_l[-50:])\n\n# +\n# vocab: dictionary that has the index of the corresponding words\nvocab = {} \n\n# Get the index of the corresponding words. \nfor i, word in enumerate(sorted(voc_l)): \n vocab[word] = i \n \nprint(\"Vocabulary dictionary, key is the word, value is a unique integer\")\ncnt = 0\nfor k,v in vocab.items():\n print(f\"{k}:{v}\")\n cnt += 1\n if cnt > 20:\n break\n\n# +\n# load in the test corpus\nwith open(\"WSJ_24.pos\", 'r') as f:\n y = f.readlines()\n\nprint(\"A sample of the test corpus\")\nprint(y[0:10])\n\n# +\n#corpus without tags, preprocessed\n_, prep = preprocess(vocab, \"test.words\") \n\nprint('The length of the preprocessed test corpus: ', len(prep))\nprint('This is a sample of the test_corpus: ')\nprint(prep[0:10])\n\n\n# -\n\n# <a name='1'></a>\n# # Part 1: Parts-of-speech tagging \n#\n# <a name='1.1'></a>\n# ## Part 1.1 - Training\n# You will start with the simplest possible parts-of-speech tagger and we will build up to the state of the art. \n#\n# In this section, you will find the words that are not ambiguous. \n# - For example, the word `is` is a verb and it is not ambiguous. \n# - In the `WSJ` corpus, $86$% of the token are unambiguous (meaning they have only one tag) \n# - About $14\\%$ are ambiguous (meaning that they have more than one tag)\n#\n# <img src = \"pos.png\" style=\"width:400px;height:250px;\"/>\n#\n# Before you start predicting the tags of each word, you will need to compute a few dictionaries that will help you to generate the tables. \n\n# #### Transition counts\n# - The first dictionary is the `transition_counts` dictionary which computes the number of times each tag happened next to another tag. \n#\n# This dictionary will be used to compute: \n# $$P(t_i |t_{i-1}) \\tag{1}$$\n#\n# This is the probability of a tag at position $i$ given the tag at position $i-1$.\n#\n# In order for you to compute equation 1, you will create a `transition_counts` dictionary where \n# - The keys are `(prev_tag, tag)`\n# - The values are the number of times those two tags appeared in that order. \n\n# #### Emission counts\n#\n# The second dictionary you will compute is the `emission_counts` dictionary. This dictionary will be used to compute:\n#\n# $$P(w_i|t_i)\\tag{2}$$\n#\n# In other words, you will use it to compute the probability of a word given its tag. \n#\n# In order for you to compute equation 2, you will create an `emission_counts` dictionary where \n# - The keys are `(tag, word)` \n# - The values are the number of times that pair showed up in your training set. \n\n# #### Tag counts\n#\n# The last dictionary you will compute is the `tag_counts` dictionary. \n# - The key is the tag \n# - The value is the number of times each tag appeared.\n\n# <a name='ex-01'></a>\n# ### Exercise 01\n#\n# **Instructions:** Write a program that takes in the `training_corpus` and returns the three dictionaries mentioned above `transition_counts`, `emission_counts`, and `tag_counts`. \n# - `emission_counts`: maps (tag, word) to the number of times it happened. \n# - `transition_counts`: maps (prev_tag, tag) to the number of times it has appeared. \n# - `tag_counts`: maps (tag) to the number of times it has occured. \n#\n# Implementation note: This routine utilises *defaultdict*, which is a subclass of *dict*. \n# - A standard Python dictionary throws a *KeyError* if you try to access an item with a key that is not currently in the dictionary. \n# - In contrast, the *defaultdict* will create an item of the type of the argument, in this case an integer with the default value of 0. \n# - See [defaultdict](https://docs.python.org/3.3/library/collections.html#defaultdict-objects).\n\n# UNQ_C1 (UNIQUE CELL IDENTIFIER, DO NOT EDIT)\n# GRADED FUNCTION: create_dictionaries\ndef create_dictionaries(training_corpus, vocab):\n \"\"\"\n Input: \n training_corpus: a corpus where each line has a word followed by its tag.\n vocab: a dictionary where keys are words in vocabulary and value is an index\n Output: \n emission_counts: a dictionary where the keys are (tag, word) and the values are the counts\n transition_counts: a dictionary where the keys are (prev_tag, tag) and the values are the counts\n tag_counts: a dictionary where the keys are the tags and the values are the counts\n \"\"\"\n \n # initialize the dictionaries using defaultdict\n emission_counts = defaultdict(int)\n transition_counts = defaultdict(int)\n tag_counts = defaultdict(int)\n \n # Initialize \"prev_tag\" (previous tag) with the start state, denoted by '--s--'\n prev_tag = '--s--' \n \n # use 'i' to track the line number in the corpus\n i = 0 \n \n # Each item in the training corpus contains a word and its POS tag\n # Go through each word and its tag in the training corpus\n for word_tag in training_corpus:\n \n # Increment the word_tag count\n i += 1\n \n # Every 50,000 words, print the word count\n if i % 50000 == 0:\n print(f\"word count = {i}\")\n \n ### START CODE HERE (Replace instances of 'None' with your code) ###\n # get the word and tag using the get_word_tag helper function (imported from utils_pos.py)\n word, tag = get_word_tag(word_tag, vocab)\n \n # Increment the transition count for the previous word and tag\n transition_counts[(prev_tag, tag)] += 1\n \n # Increment the emission count for the tag and word\n emission_counts[(tag, word)] += 1\n\n # Increment the tag count\n tag_counts[tag] += 1\n\n # Set the previous tag to this tag (for the next iteration of the loop)\n prev_tag = tag\n \n ### END CODE HERE ###\n \n return emission_counts, transition_counts, tag_counts\n\n\nemission_counts, transition_counts, tag_counts = create_dictionaries(training_corpus, vocab)\n\n# get all the POS states\nstates = sorted(tag_counts.keys())\nprint(f\"Number of POS tags (number of 'states'): {len(states)}\")\nprint(\"View these POS tags (states)\")\nprint(states)\n\n# ##### Expected Output\n#\n# ```CPP\n# Number of POS tags (number of 'states'46\n# View these states\n# ['#', '$', \"''\", '(', ')', ',', '--s--', '.', ':', 'CC', 'CD', 'DT', 'EX', 'FW', 'IN', 'JJ', 'JJR', 'JJS', 'LS', 'MD', 'NN', 'NNP', 'NNPS', 'NNS', 'PDT', 'POS', 'PRP', 'PRP$', 'RB', 'RBR', 'RBS', 'RP', 'SYM', 'TO', 'UH', 'VB', 'VBD', 'VBG', 'VBN', 'VBP', 'VBZ', 'WDT', 'WP', 'WP$', 'WRB', '``']\n# ```\n\n# The 'states' are the Parts-of-speech designations found in the training data. They will also be referred to as 'tags' or POS in this assignment. \n#\n# - \"NN\" is noun, singular, \n# - 'NNS' is noun, plural. \n# - In addition, there are helpful tags like '--s--' which indicate a start of a sentence.\n# - You can get a more complete description at [Penn Treebank II tag set](https://www.clips.uantwerpen.be/pages/mbsp-tags). \n\n# +\nprint(\"transition examples: \")\nfor ex in list(transition_counts.items())[:3]:\n print(ex)\nprint()\n\nprint(\"emission examples: \")\nfor ex in list(emission_counts.items())[200:203]:\n print (ex)\nprint()\n\nprint(\"ambiguous word example: \")\nfor tup,cnt in emission_counts.items():\n if tup[1] == 'back': print (tup, cnt) \n\n\n# -\n\n# ##### Expected Output\n#\n# ```CPP\n# transition examples: \n# (('--s--', 'IN'), 5050)\n# (('IN', 'DT'), 32364)\n# (('DT', 'NNP'), 9044)\n#\n# emission examples: \n# (('DT', 'any'), 721)\n# (('NN', 'decrease'), 7)\n# (('NN', 'insider-trading'), 5)\n#\n# ambiguous word example: \n# ('RB', 'back') 304\n# ('VB', 'back') 20\n# ('RP', 'back') 84\n# ('JJ', 'back') 25\n# ('NN', 'back') 29\n# ('VBP', 'back') 4\n# ```\n\n# <a name='1.2'></a>\n# ### Part 1.2 - Testing\n#\n# Now you will test the accuracy of your parts-of-speech tagger using your `emission_counts` dictionary. \n# - Given your preprocessed test corpus `prep`, you will assign a parts-of-speech tag to every word in that corpus. \n# - Using the original tagged test corpus `y`, you will then compute what percent of the tags you got correct. \n\n# <a name='ex-02'></a>\n# ### Exercise 02\n#\n# **Instructions:** Implement `predict_pos` that computes the accuracy of your model. \n#\n# - This is a warm up exercise. \n# - To assign a part of speech to a word, assign the most frequent POS for that word in the training set. \n# - Then evaluate how well this approach works. Each time you predict based on the most frequent POS for the given word, check whether the actual POS of that word is the same. If so, the prediction was correct!\n# - Calculate the accuracy as the number of correct predictions divided by the total number of words for which you predicted the POS tag.\n\n# +\n# UNQ_C2 (UNIQUE CELL IDENTIFIER, DO NOT EDIT)\n# GRADED FUNCTION: predict_pos\n\ndef predict_pos(prep, y, emission_counts, vocab, states):\n '''\n Input: \n prep: a preprocessed version of 'y'. A list with the 'word' component of the tuples.\n y: a corpus composed of a list of tuples where each tuple consists of (word, POS)\n emission_counts: a dictionary where the keys are (tag,word) tuples and the value is the count\n vocab: a dictionary where keys are words in vocabulary and value is an index\n states: a sorted list of all possible tags for this assignment\n Output: \n accuracy: Number of times you classified a word correctly\n '''\n \n # Initialize the number of correct predictions to zero\n num_correct = 0\n \n # Get the (tag, word) tuples, stored as a set\n all_words = set(emission_counts.keys())\n \n # Get the number of (word, POS) tuples in the corpus 'y'\n total = len(y)\n for word, y_tup in zip(prep, y): \n\n # Split the (word, POS) string into a list of two items\n y_tup_l = y_tup.split()\n \n # Verify that y_tup contain both word and POS\n if len(y_tup_l) == 2:\n \n # Set the true POS label for this word\n true_label = y_tup_l[1]\n\n else:\n # If the y_tup didn't contain word and POS, go to next word\n continue\n \n count_final = 0\n pos_final = ''\n \n # If the word is in the vocabulary...\n if word in vocab:\n for pos in states:\n\n ### START CODE HERE (Replace instances of 'None' with your code) ###\n \n # define the key as the tuple containing the POS and word\n key = (pos, word)\n\n # check if the (pos, word) key exists in the emission_counts dictionary\n if key in emission_counts: # complete this line\n\n # get the emission count of the (pos,word) tuple \n count = emission_counts[key]\n\n # keep track of the POS with the largest count\n if count > count_final: # complete this line\n\n # update the final count (largest count)\n count_final = count\n\n # update the final POS\n pos_final = pos\n\n # If the final POS (with the largest count) matches the true POS:\n if pos_final == true_label: # complete this line\n \n # Update the number of correct predictions\n num_correct += 1\n \n ### END CODE HERE ###\n accuracy = num_correct / total\n \n return accuracy\n\n\n# -\n\naccuracy_predict_pos = predict_pos(prep, y, emission_counts, vocab, states)\nprint(f\"Accuracy of prediction using predict_pos is {accuracy_predict_pos:.4f}\")\n\n\n# ##### Expected Output\n# ```CPP\n# Accuracy of prediction using predict_pos is 0.8889\n# ```\n#\n# 88.9% is really good for this warm up exercise. With hidden markov models, you should be able to get **95% accuracy.**\n\n# <a name='2'></a>\n# # Part 2: Hidden Markov Models for POS\n#\n# Now you will build something more context specific. Concretely, you will be implementing a Hidden Markov Model (HMM) with a Viterbi decoder\n# - The HMM is one of the most commonly used algorithms in Natural Language Processing, and is a foundation to many deep learning techniques you will see in this specialization. \n# - In addition to parts-of-speech tagging, HMM is used in speech recognition, speech synthesis, etc. \n# - By completing this part of the assignment you will get a 95% accuracy on the same dataset you used in Part 1.\n#\n# The Markov Model contains a number of states and the probability of transition between those states. \n# - In this case, the states are the parts-of-speech. \n# - A Markov Model utilizes a transition matrix, `A`. \n# - A Hidden Markov Model adds an observation or emission matrix `B` which describes the probability of a visible observation when we are in a particular state. \n# - In this case, the emissions are the words in the corpus\n# - The state, which is hidden, is the POS tag of that word.\n\n# <a name='2.1'></a>\n# ## Part 2.1 Generating Matrices\n#\n# ### Creating the 'A' transition probabilities matrix\n# Now that you have your `emission_counts`, `transition_counts`, and `tag_counts`, you will start implementing the Hidden Markov Model. \n#\n# This will allow you to quickly construct the \n# - `A` transition probabilities matrix.\n# - and the `B` emission probabilities matrix. \n#\n# You will also use some smoothing when computing these matrices. \n#\n# Here is an example of what the `A` transition matrix would look like (it is simplified to 5 tags for viewing. It is 46x46 in this assignment.):\n#\n#\n# |**A** |...| RBS | RP | SYM | TO | UH|...\n# | --- ||---:-------------| ------------ | ------------ | -------- | ---------- |----\n# |**RBS** |...|2.217069e-06 |2.217069e-06 |2.217069e-06 |0.008870 |2.217069e-06|...\n# |**RP** |...|3.756509e-07 |7.516775e-04 |3.756509e-07 |0.051089 |3.756509e-07|...\n# |**SYM** |...|1.722772e-05 |1.722772e-05 |1.722772e-05 |0.000017 |1.722772e-05|...\n# |**TO** |...|4.477336e-05 |4.472863e-08 |4.472863e-08 |0.000090 |4.477336e-05|...\n# |**UH** |...|1.030439e-05 |1.030439e-05 |1.030439e-05 |0.061837 |3.092348e-02|...\n# | ... |...| ... | ... | ... | ... | ... | ...\n#\n# Note that the matrix above was computed with smoothing. \n#\n# Each cell gives you the probability to go from one part of speech to another. \n# - In other words, there is a 4.47e-8 chance of going from parts-of-speech `TO` to `RP`. \n# - The sum of each row has to equal 1, because we assume that the next POS tag must be one of the available columns in the table.\n#\n# The smoothing was done as follows: \n#\n# $$ P(t_i | t_{i-1}) = \\frac{C(t_{i-1}, t_{i}) + \\alpha }{C(t_{i-1}) +\\alpha * N}\\tag{3}$$\n#\n# - $N$ is the total number of tags\n# - $C(t_{i-1}, t_{i})$ is the count of the tuple (previous POS, current POS) in `transition_counts` dictionary.\n# - $C(t_{i-1})$ is the count of the previous POS in the `tag_counts` dictionary.\n# - $\\alpha$ is a smoothing parameter.\n\n# <a name='ex-03'></a>\n# ### Exercise 03\n#\n# **Instructions:** Implement the `create_transition_matrix` below for all tags. Your task is to output a matrix that computes equation 3 for each cell in matrix `A`. \n\n# UNQ_C3 (UNIQUE CELL IDENTIFIER, DO NOT EDIT)\n# GRADED FUNCTION: create_transition_matrix\ndef create_transition_matrix(alpha, tag_counts, transition_counts):\n ''' \n Input: \n alpha: number used for smoothing\n tag_counts: a dictionary mapping each tag to its respective count\n transition_counts: transition count for the previous word and tag\n Output:\n A: matrix of dimension (num_tags,num_tags)\n '''\n # Get a sorted list of unique POS tags\n all_tags = sorted(tag_counts.keys())\n \n # Count the number of unique POS tags\n num_tags = len(all_tags)\n \n # Initialize the transition matrix 'A'\n A = np.zeros((num_tags,num_tags))\n \n # Get the unique transition tuples (previous POS, current POS)\n trans_keys = set(transition_counts.keys())\n \n ### START CODE HERE (Replace instances of 'None' with your code) ### \n \n # Go through each row of the transition matrix A\n for i in range(num_tags):\n \n # Go through each column of the transition matrix A\n for j in range(num_tags):\n\n # Initialize the count of the (prev POS, current POS) to zero\n count = 0\n \n # Define the tuple (prev POS, current POS)\n # Get the tag at position i and tag at position j (from the all_tags list)\n key = (all_tags[i], all_tags[j])\n\n # Check if the (prev POS, current POS) tuple \n # exists in the transition counts dictionary\n if key in transition_counts: #complete this line\n # Get count from the transition_counts dictionary \n # for the (prev POS, current POS) tuple\n count = transition_counts[key]\n \n # Get the count of the previous tag (index position i) from tag_counts\n count_prev_tag = tag_counts[all_tags[i]]\n \n # Apply smoothing using count of the tuple, alpha, \n # count of previous tag, alpha, and total number of tags\n A[i,j] = (count + alpha) / (count_prev_tag + (alpha * num_tags))\n\n ### END CODE HERE ###\n \n return A\n\n\n# +\nalpha = 0.001\nA = create_transition_matrix(alpha, tag_counts, transition_counts)\n# Testing your function\nprint(f\"A at row 0, col 0: {A[0,0]:.9f}\")\nprint(f\"A at row 3, col 1: {A[3,1]:.4f}\")\n\nprint(\"View a subset of transition matrix A\")\nA_sub = pd.DataFrame(A[30:35,30:35], index=states[30:35], columns = states[30:35] )\nprint(A_sub)\n\n\n# -\n\n# ##### Expected Output\n# ```CPP\n# A at row 0, col 0: 0.000007040\n# A at row 3, col 1: 0.1691\n# View a subset of transition matrix A\n# RBS RP SYM TO UH\n# RBS 2.217069e-06 2.217069e-06 2.217069e-06 0.008870 2.217069e-06\n# RP 3.756509e-07 7.516775e-04 3.756509e-07 0.051089 3.756509e-07\n# SYM 1.722772e-05 1.722772e-05 1.722772e-05 0.000017 1.722772e-05\n# TO 4.477336e-05 4.472863e-08 4.472863e-08 0.000090 4.477336e-05\n# UH 1.030439e-05 1.030439e-05 1.030439e-05 0.061837 3.092348e-02\n# ```\n\n# ### Create the 'B' emission probabilities matrix\n#\n# Now you will create the `B` transition matrix which computes the emission probability. \n#\n# You will use smoothing as defined below: \n#\n# $$P(w_i | t_i) = \\frac{C(t_i, word_i)+ \\alpha}{C(t_{i}) +\\alpha * N}\\tag{4}$$\n#\n# - $C(t_i, word_i)$ is the number of times $word_i$ was associated with $tag_i$ in the training data (stored in `emission_counts` dictionary).\n# - $C(t_i)$ is the number of times $tag_i$ was in the training data (stored in `tag_counts` dictionary).\n# - $N$ is the number of words in the vocabulary\n# - $\\alpha$ is a smoothing parameter. \n#\n# The matrix `B` is of dimension (num_tags, N), where num_tags is the number of possible parts-of-speech tags. \n#\n# Here is an example of the matrix, only a subset of tags and words are shown: \n# <p style='text-align: center;'> <b>B Emissions Probability Matrix (subset)</b> </p>\n#\n# |**B**| ...| 725 | adroitly | engineers | promoted | synergy| ...|\n# |----|----|--------------|--------------|--------------|--------------|-------------|----|\n# |**CD** | ...| **8.201296e-05** | 2.732854e-08 | 2.732854e-08 | 2.732854e-08 | 2.732854e-08| ...|\n# |**NN** | ...| 7.521128e-09 | 7.521128e-09 | 7.521128e-09 | 7.521128e-09 | **2.257091e-05**| ...|\n# |**NNS** | ...| 1.670013e-08 | 1.670013e-08 |**4.676203e-04** | 1.670013e-08 | 1.670013e-08| ...|\n# |**VB** | ...| 3.779036e-08 | 3.779036e-08 | 3.779036e-08 | 3.779036e-08 | 3.779036e-08| ...|\n# |**RB** | ...| 3.226454e-08 | **6.456135e-05** | 3.226454e-08 | 3.226454e-08 | 3.226454e-08| ...|\n# |**RP** | ...| 3.723317e-07 | 3.723317e-07 | 3.723317e-07 | **3.723317e-07** | 3.723317e-07| ...|\n# | ... | ...| ... | ... | ... | ... | ... | ...|\n#\n#\n\n# <a name='ex-04'></a>\n# ### Exercise 04\n# **Instructions:** Implement the `create_emission_matrix` below that computes the `B` emission probabilities matrix. Your function takes in $\\alpha$, the smoothing parameter, `tag_counts`, which is a dictionary mapping each tag to its respective count, the `emission_counts` dictionary where the keys are (tag, word) and the values are the counts. Your task is to output a matrix that computes equation 4 for each cell in matrix `B`. \n\n# +\n# UNQ_C4 (UNIQUE CELL IDENTIFIER, DO NOT EDIT)\n# GRADED FUNCTION: create_emission_matrix\n\ndef create_emission_matrix(alpha, tag_counts, emission_counts, vocab):\n '''\n Input: \n alpha: tuning parameter used in smoothing \n tag_counts: a dictionary mapping each tag to its respective count\n emission_counts: a dictionary where the keys are (tag, word) and the values are the counts\n vocab: a dictionary where keys are words in vocabulary and value is an index.\n within the function it'll be treated as a list\n Output:\n B: a matrix of dimension (num_tags, len(vocab))\n '''\n \n # get the number of POS tag\n num_tags = len(tag_counts)\n \n # Get a list of all POS tags\n all_tags = sorted(tag_counts.keys())\n \n # Get the total number of unique words in the vocabulary\n num_words = len(vocab)\n \n # Initialize the emission matrix B with places for\n # tags in the rows and words in the columns\n B = np.zeros((num_tags, num_words))\n \n # Get a set of all (POS, word) tuples \n # from the keys of the emission_counts dictionary\n emis_keys = set(list(emission_counts.keys()))\n \n ### START CODE HERE (Replace instances of 'None' with your code) ###\n \n # Go through each row (POS tags)\n for i in range(num_tags): # complete this line\n \n # Go through each column (words)\n for j in range(num_words): # complete this line\n\n # Initialize the emission count for the (POS tag, word) to zero\n count = 0\n \n # Define the (POS tag, word) tuple for this row and column\n key = (all_tags[i], vocab[j])\n\n # check if the (POS tag, word) tuple exists as a key in emission counts\n if key in emission_counts.keys(): # complete this line\n \n # Get the count of (POS tag, word) from the emission_counts d\n count = emission_counts[key]\n \n # Get the count of the POS tag\n count_tag = tag_counts[all_tags[i]]\n \n # Apply smoothing and store the smoothed value \n # into the emission matrix B for this row and column\n B[i,j] = (count + alpha) / (count_tag + alpha*num_words)\n\n ### END CODE HERE ###\n return B\n\n\n# +\n# creating your emission probability matrix. this takes a few minutes to run. \nB = create_emission_matrix(alpha, tag_counts, emission_counts, list(vocab))\n\nprint(f\"View Matrix position at row 0, column 0: {B[0,0]:.9f}\")\nprint(f\"View Matrix position at row 3, column 1: {B[3,1]:.9f}\")\n\n# Try viewing emissions for a few words in a sample dataframe\ncidx = ['725','adroitly','engineers', 'promoted', 'synergy']\n\n# Get the integer ID for each word\ncols = [vocab[a] for a in cidx]\n\n# Choose POS tags to show in a sample dataframe\nrvals =['CD','NN','NNS', 'VB','RB','RP']\n\n# For each POS tag, get the row number from the 'states' list\nrows = [states.index(a) for a in rvals]\n\n# Get the emissions for the sample of words, and the sample of POS tags\nB_sub = pd.DataFrame(B[np.ix_(rows,cols)], index=rvals, columns = cidx )\nprint(B_sub)\n\n\n# -\n\n# ##### Expected Output\n#\n# ```CPP\n# View Matrix position at row 0, column 0: 0.000006032\n# View Matrix position at row 3, column 1: 0.000000720\n# 725 adroitly engineers promoted synergy\n# CD 8.201296e-05 2.732854e-08 2.732854e-08 2.732854e-08 2.732854e-08\n# NN 7.521128e-09 7.521128e-09 7.521128e-09 7.521128e-09 2.257091e-05\n# NNS 1.670013e-08 1.670013e-08 4.676203e-04 1.670013e-08 1.670013e-08\n# VB 3.779036e-08 3.779036e-08 3.779036e-08 3.779036e-08 3.779036e-08\n# RB 3.226454e-08 6.456135e-05 3.226454e-08 3.226454e-08 3.226454e-08\n# RP 3.723317e-07 3.723317e-07 3.723317e-07 3.723317e-07 3.723317e-07\n# ```\n\n# <a name='3'></a>\n# # Part 3: Viterbi Algorithm and Dynamic Programming\n#\n# In this part of the assignment you will implement the Viterbi algorithm which makes use of dynamic programming. Specifically, you will use your two matrices, `A` and `B` to compute the Viterbi algorithm. We have decomposed this process into three main steps for you. \n#\n# * **Initialization** - In this part you initialize the `best_paths` and `best_probabilities` matrices that you will be populating in `feed_forward`.\n# * **Feed forward** - At each step, you calculate the probability of each path happening and the best paths up to that point. \n# * **Feed backward**: This allows you to find the best path with the highest probabilities. \n#\n# <a name='3.1'></a>\n# ## Part 3.1: Initialization \n#\n# You will start by initializing two matrices of the same dimension. \n#\n# - best_probs: Each cell contains the probability of going from one POS tag to a word in the corpus.\n#\n# - best_paths: A matrix that helps you trace through the best possible path in the corpus. \n\n# <a name='ex-05'></a>\n# ### Exercise 05\n# **Instructions**: \n# Write a program below that initializes the `best_probs` and the `best_paths` matrix. \n#\n# Both matrices will be initialized to zero except for column zero of `best_probs`. \n# - Column zero of `best_probs` is initialized with the assumption that the first word of the corpus was preceded by a start token (\"--s--\"). \n# - This allows you to reference the **A** matrix for the transition probability\n#\n# Here is how to initialize column 0 of `best_probs`:\n# - The probability of the best path going from the start index to a given POS tag indexed by integer $i$ is denoted by $\\textrm{best_probs}[s_{idx}, i]$.\n# - This is estimated as the probability that the start tag transitions to the POS denoted by index $i$: $\\mathbf{A}[s_{idx}, i]$ AND that the POS tag denoted by $i$ emits the first word of the given corpus, which is $\\mathbf{B}[i, vocab[corpus[0]]]$.\n# - Note that vocab[corpus[0]] refers to the first word of the corpus (the word at position 0 of the corpus). \n# - **vocab** is a dictionary that returns the unique integer that refers to that particular word.\n#\n# Conceptually, it looks like this:\n# $\\textrm{best_probs}[s_{idx}, i] = \\mathbf{A}[s_{idx}, i] \\times \\mathbf{B}[i, corpus[0] ]$\n#\n#\n# In order to avoid multiplying and storing small values on the computer, we'll take the log of the product, which becomes the sum of two logs:\n#\n# $best\\_probs[i,0] = log(A[s_{idx}, i]) + log(B[i, vocab[corpus[0]]$\n#\n# Also, to avoid taking the log of 0 (which is defined as negative infinity), the code itself will just set $best\\_probs[i,0] = float('-inf')$ when $A[s_{idx}, i] == 0$\n#\n#\n# So the implementation to initialize $best\\_probs$ looks like this:\n#\n# $ if A[s_{idx}, i] <> 0 : best\\_probs[i,0] = log(A[s_{idx}, i]) + log(B[i, vocab[corpus[0]]])$\n#\n# $ if A[s_{idx}, i] == 0 : best\\_probs[i,0] = float('-inf')$\n#\n# Please use [math.log](https://docs.python.org/3/library/math.html) to compute the natural logarithm.\n\n# The example below shows the initialization assuming the corpus starts with the phrase \"Loss tracks upward\".\n#\n# <img src = \"Initialize4.png\"/>\n\n# Represent infinity and negative infinity like this:\n#\n# ```CPP\n# float('inf')\n# float('-inf')\n# ```\n\n# UNQ_C5 (UNIQUE CELL IDENTIFIER, DO NOT EDIT)\n# GRADED FUNCTION: initialize\ndef initialize(states, tag_counts, A, B, corpus, vocab):\n '''\n Input: \n states: a list of all possible parts-of-speech\n tag_counts: a dictionary mapping each tag to its respective count\n A: Transition Matrix of dimension (num_tags, num_tags)\n B: Emission Matrix of dimension (num_tags, len(vocab))\n corpus: a sequence of words whose POS is to be identified in a list \n vocab: a dictionary where keys are words in vocabulary and value is an index\n Output:\n best_probs: matrix of dimension (num_tags, len(corpus)) of floats\n best_paths: matrix of dimension (num_tags, len(corpus)) of integers\n '''\n # Get the total number of unique POS tags\n num_tags = len(tag_counts)\n \n # Initialize best_probs matrix \n # POS tags in the rows, number of words in the corpus as the columns\n best_probs = np.zeros((num_tags, len(corpus)))\n \n # Initialize best_paths matrix\n # POS tags in the rows, number of words in the corpus as columns\n best_paths = np.zeros((num_tags, len(corpus)), dtype=int)\n \n # Define the start token\n s_idx = states.index(\"--s--\")\n ### START CODE HERE (Replace instances of 'None' with your code) ###\n \n # Go through each of the POS tags\n for i in range(num_tags): # complete this line\n \n # Handle the special case when the transition from start token to POS tag i is zero\n if A[s_idx, i] == 0: # complete this line\n \n # Initialize best_probs at POS tag 'i', column 0, to negative infinity\n best_probs[i,0] = float('-inf') \n \n # For all other cases when transition from start token to POS tag i is non-zero:\n else:\n \n # Initialize best_probs at POS tag 'i', column 0\n # Check the formula in the instructions above\n best_probs[i,0] = np.log(A[s_idx, i]) + np.log(B[i, vocab[corpus[0]]])\n \n ### END CODE HERE ### \n return best_probs, best_paths\n\n\nbest_probs, best_paths = initialize(states, tag_counts, A, B, prep, vocab)\n\n# Test the function\nprint(f\"best_probs[0,0]: {best_probs[0,0]:.4f}\") \nprint(f\"best_paths[2,3]: {best_paths[2,3]:.4f}\")\n\n\n# ##### Expected Output\n#\n# ```CPP\n# best_probs[0,0]: -22.6098\n# best_paths[2,3]: 0.0000\n# ```\n#\n\n# <a name='3.2'></a>\n# ## Part 3.2 Viterbi Forward\n#\n# In this part of the assignment, you will implement the `viterbi_forward` segment. In other words, you will populate your `best_probs` and `best_paths` matrices.\n# - Walk forward through the corpus.\n# - For each word, compute a probability for each possible tag. \n# - Unlike the previous algorithm `predict_pos` (the 'warm-up' exercise), this will include the path up to that (word,tag) combination. \n#\n# Here is an example with a three-word corpus \"Loss tracks upward\":\n# - Note, in this example, only a subset of states (POS tags) are shown in the diagram below, for easier reading. \n# - In the diagram below, the first word \"Loss\" is already initialized. \n# - The algorithm will compute a probability for each of the potential tags in the second and future words. \n#\n# Compute the probability that the tag of the second work ('tracks') is a verb, 3rd person singular present (VBZ). \n# - In the `best_probs` matrix, go to the column of the second word ('tracks'), and row 40 (VBZ), this cell is highlighted in light orange in the diagram below.\n# - Examine each of the paths from the tags of the first word ('Loss') and choose the most likely path. \n# - An example of the calculation for **one** of those paths is the path from ('Loss', NN) to ('tracks', VBZ).\n# - The log of the probability of the path up to and including the first word 'Loss' having POS tag NN is $-14.32$. The `best_probs` matrix contains this value -14.32 in the column for 'Loss' and row for 'NN'.\n# - Find the probability that NN transitions to VBZ. To find this probability, go to the `A` transition matrix, and go to the row for 'NN' and the column for 'VBZ'. The value is $4.37e-02$, which is circled in the diagram, so add $-14.32 + log(4.37e-02)$. \n# - Find the log of the probability that the tag VBS would 'emit' the word 'tracks'. To find this, look at the 'B' emission matrix in row 'VBZ' and the column for the word 'tracks'. The value $4.61e-04$ is circled in the diagram below. So add $-14.32 + log(4.37e-02) + log(4.61e-04)$.\n# - The sum of $-14.32 + log(4.37e-02) + log(4.61e-04)$ is $-25.13$. Store $-25.13$ in the `best_probs` matrix at row 'VBZ' and column 'tracks' (as seen in the cell that is highlighted in light orange in the diagram).\n# - All other paths in best_probs are calculated. Notice that $-25.13$ is greater than all of the other values in column 'tracks' of matrix `best_probs`, and so the most likely path to 'VBZ' is from 'NN'. 'NN' is in row 20 of the `best_probs` matrix, so $20$ is the most likely path.\n# - Store the most likely path $20$ in the `best_paths` table. This is highlighted in light orange in the diagram below.\n\n# The formula to compute the probability and path for the $i^{th}$ word in the $corpus$, the prior word $i-1$ in the corpus, current POS tag $j$, and previous POS tag $k$ is:\n#\n# $\\mathrm{prob} = \\mathbf{best\\_prob}_{k, i-1} + \\mathrm{log}(\\mathbf{A}_{k, j}) + \\mathrm{log}(\\mathbf{B}_{j, vocab(corpus_{i})})$\n#\n# where $corpus_{i}$ is the word in the corpus at index $i$, and $vocab$ is the dictionary that gets the unique integer that represents a given word.\n#\n# $\\mathrm{path} = k$\n#\n# where $k$ is the integer representing the previous POS tag.\n#\n\n# <a name='ex-06'></a>\n#\n# ### Exercise 06\n#\n# Instructions: Implement the `viterbi_forward` algorithm and store the best_path and best_prob for every possible tag for each word in the matrices `best_probs` and `best_tags` using the pseudo code below.\n#\n# `for each word in the corpus\n#\n# for each POS tag type that this word may be\n# \n# for POS tag type that the previous word could be\n# \n# compute the probability that the previous word had a given POS tag, that the current word has a given POS tag, and that the POS tag would emit this current word.\n# \n# retain the highest probability computed for the current word\n# \n# set best_probs to this highest probability\n# \n# set best_paths to the index 'k', representing the POS tag of the previous word which produced the highest probability `\n#\n# Please use [math.log](https://docs.python.org/3/library/math.html) to compute the natural logarithm.\n\n# <img src = \"Forward4.PNG\"/>\n\n# <details> \n# <summary>\n# <font size=\"3\" color=\"darkgreen\"><b>Hints</b></font>\n# </summary>\n# <p>\n# <ul>\n# <li>Remember that when accessing emission matrix B, the column index is the unique integer ID associated with the word. It can be accessed by using the 'vocab' dictionary, where the key is the word, and the value is the unique integer ID for that word.</li>\n# </ul>\n# </p>\n#\n\n# UNQ_C6 (UNIQUE CELL IDENTIFIER, DO NOT EDIT)\n# GRADED FUNCTION: viterbi_forward\ndef viterbi_forward(A, B, test_corpus, best_probs, best_paths, vocab):\n '''\n Input: \n A, B: The transition and emission matrices respectively\n test_corpus: a list containing a preprocessed corpus\n best_probs: an initilized matrix of dimension (num_tags, len(corpus))\n best_paths: an initilized matrix of dimension (num_tags, len(corpus))\n vocab: a dictionary where keys are words in vocabulary and value is an index \n Output: \n best_probs: a completed matrix of dimension (num_tags, len(corpus))\n best_paths: a completed matrix of dimension (num_tags, len(corpus))\n '''\n # Get the number of unique POS tags (which is the num of rows in best_probs)\n num_tags = best_probs.shape[0]\n \n # Go through every word in the corpus starting from word 1\n # Recall that word 0 was initialized in `initialize()`\n for i in range(1, len(test_corpus)): \n \n # Print number of words processed, every 5000 words\n if i % 5000 == 0:\n print(\"Words processed: {:>8}\".format(i))\n \n ### START CODE HERE (Replace instances of 'None' with your code EXCEPT the first 'best_path_i = None') ###\n # For each unique POS tag that the current word can be\n for j in range(num_tags): # complete this line\n \n # Initialize best_prob for word i to negative infinity\n best_prob_i = float(\"-inf\")\n \n # Initialize best_path for current word i to None\n best_path_i = None\n\n # For each POS tag that the previous word can be:\n for k in range(num_tags): # complete this line\n \n # Calculate the probability = \n # best probs of POS tag k, previous word i-1 + \n # log(prob of transition from POS k to POS j) + \n # log(prob that emission of POS j is word i)\n prob = best_probs[k, i-1] + math.log(A[k, j]) + math.log(B[j, vocab[test_corpus[i]]])\n\n\n # check if this path's probability is greater than\n # the best probability up to and before this point\n if prob > best_prob_i: # complete this line\n \n # Keep track of the best probability\n best_prob_i = prob\n \n # keep track of the POS tag of the previous word\n # that is part of the best path. \n # Save the index (integer) associated with \n # that previous word's POS tag\n best_path_i = k\n\n # Save the best probability for the \n # given current word's POS tag\n # and the position of the current word inside the corpus\n best_probs[j,i] = best_prob_i\n \n # Save the unique integer ID of the previous POS tag\n # into best_paths matrix, for the POS tag of the current word\n # and the position of the current word inside the corpus.\n best_paths[j,i] = best_path_i\n\n ### END CODE HERE ###\n return best_probs, best_paths\n\n# Run the `viterbi_forward` function to fill in the `best_probs` and `best_paths` matrices.\n#\n# **Note** that this will take a few minutes to run. There are about 30,000 words to process.\n\n# this will take a few minutes to run => processes ~ 30,000 words\nbest_probs, best_paths = viterbi_forward(A, B, prep, best_probs, best_paths, vocab)\n\n# Test this function \nprint(f\"best_probs[0,1]: {best_probs[0,1]:.4f}\") \nprint(f\"best_probs[0,4]: {best_probs[0,4]:.4f}\") \n\n\n# ##### Expected Output\n#\n# ```CPP\n# best_probs[0,1]: -24.7822\n# best_probs[0,4]: -49.5601\n# ```\n\n# <a name='3.3'></a>\n# ## Part 3.3 Viterbi backward\n#\n# Now you will implement the Viterbi backward algorithm.\n# - The Viterbi backward algorithm gets the predictions of the POS tags for each word in the corpus using the `best_paths` and the `best_probs` matrices.\n#\n# The example below shows how to walk backwards through the best_paths matrix to get the POS tags of each word in the corpus. Recall that this example corpus has three words: \"Loss tracks upward\".\n#\n# POS tag for 'upward' is `RB`\n# - Select the the most likely POS tag for the last word in the corpus, 'upward' in the `best_prob` table.\n# - Look for the row in the column for 'upward' that has the largest probability.\n# - Notice that in row 28 of `best_probs`, the estimated probability is -34.99, which is larger than the other values in the column. So the most likely POS tag for 'upward' is `RB` an adverb, at row 28 of `best_prob`. \n# - The variable `z` is an array that stores the unique integer ID of the predicted POS tags for each word in the corpus. In array z, at position 2, store the value 28 to indicate that the word 'upward' (at index 2 in the corpus), most likely has the POS tag associated with unique ID 28 (which is `RB`).\n# - The variable `pred` contains the POS tags in string form. So `pred` at index 2 stores the string `RB`.\n#\n#\n# POS tag for 'tracks' is `VBZ`\n# - The next step is to go backward one word in the corpus ('tracks'). Since the most likely POS tag for 'upward' is `RB`, which is uniquely identified by integer ID 28, go to the `best_paths` matrix in column 2, row 28. The value stored in `best_paths`, column 2, row 28 indicates the unique ID of the POS tag of the previous word. In this case, the value stored here is 40, which is the unique ID for POS tag `VBZ` (verb, 3rd person singular present).\n# - So the previous word at index 1 of the corpus ('tracks'), most likely has the POS tag with unique ID 40, which is `VBZ`.\n# - In array `z`, store the value 40 at position 1, and for array `pred`, store the string `VBZ` to indicate that the word 'tracks' most likely has POS tag `VBZ`.\n#\n# POS tag for 'Loss' is `NN`\n# - In `best_paths` at column 1, the unique ID stored at row 40 is 20. 20 is the unique ID for POS tag `NN`.\n# - In array `z` at position 0, store 20. In array `pred` at position 0, store `NN`.\n\n# <img src = \"Backwards5.PNG\"/>\n\n# <a name='ex-07'></a>\n# ### Exercise 07\n# Implement the `viterbi_backward` algorithm, which returns a list of predicted POS tags for each word in the corpus.\n#\n# - Note that the numbering of the index positions starts at 0 and not 1. \n# - `m` is the number of words in the corpus. \n# - So the indexing into the corpus goes from `0` to `m - 1`.\n# - Also, the columns in `best_probs` and `best_paths` are indexed from `0` to `m - 1`\n#\n#\n# **In Step 1:** \n# Loop through all the rows (POS tags) in the last entry of `best_probs` and find the row (POS tag) with the maximum value.\n# Convert the unique integer ID to a tag (a string representation) using the list `states`. \n#\n# Referring to the three-word corpus described above:\n# - `z[2] = 28`: For the word 'upward' at position 2 in the corpus, the POS tag ID is 28. Store 28 in `z` at position 2.\n# - `states[28]` is 'RB': The POS tag ID 28 refers to the POS tag 'RB'.\n# - `pred[2] = 'RB'`: In array `pred`, store the POS tag for the word 'upward'.\n#\n# **In Step 2:** \n# - Starting at the last column of best_paths, use `best_probs` to find the most likely POS tag for the last word in the corpus.\n# - Then use `best_paths` to find the most likely POS tag for the previous word. \n# - Update the POS tag for each word in `z` and in `preds`.\n#\n# Referring to the three-word example from above, read best_paths at column 2 and fill in z at position 1. \n# `z[1] = best_paths[z[2],2]` \n#\n# The small test following the routine prints the last few words of the corpus and their states to aid in debug.\n\n# UNQ_C7 (UNIQUE CELL IDENTIFIER, DO NOT EDIT)\n# GRADED FUNCTION: viterbi_backward\ndef viterbi_backward(best_probs, best_paths, corpus, states):\n '''\n This function returns the best path.\n \n '''\n # Get the number of words in the corpus\n # which is also the number of columns in best_probs, best_paths\n m = best_paths.shape[1] \n \n # Initialize array z, same length as the corpus\n z = [None] * m\n \n # Get the number of unique POS tags\n num_tags = best_probs.shape[0]\n \n # Initialize the best probability for the last word\n best_prob_for_last_word = float('-inf')\n \n # Initialize pred array, same length as corpus\n pred = [None] * m\n \n ### START CODE HERE (Replace instances of 'None' with your code) ###\n ## Step 1 ##\n \n # Go through each POS tag for the last word (last column of best_probs)\n # in order to find the row (POS tag integer ID) \n # with highest probability for the last word\n for k in range(num_tags): # complete this line\n\n # If the probability of POS tag at row k \n # is better than the previously best probability for the last word:\n if best_probs[k, -1] > best_prob_for_last_word: # complete this line\n \n # Store the new best probability for the last word\n best_prob_for_last_word = best_probs[k, -1]\n \n # Store the unique integer ID of the POS tag\n # which is also the row number in best_probs\n z[m - 1] = k\n \n # Convert the last word's predicted POS tag\n # from its unique integer ID into the string representation\n # using the 'states' list\n # store this in the 'pred' array for the last word\n pred[m - 1] = states[k]\n \n ## Step 2 ##\n # Find the best POS tags by walking backward through the best_paths\n # From the last word in the corpus to the 0th word in the corpus\n for i in range(len(corpus) - 1, -1, -1): # complete this line\n \n # Retrieve the unique integer ID of\n # the POS tag for the word at position 'i' in the corpus\n pos_tag_for_word_i = best_paths[np.argmax(best_probs[:, i]), i]\n \n # In best_paths, go to the row representing the POS tag of word i\n # and the column representing the word's position in the corpus\n # to retrieve the predicted POS for the word at position i-1 in the corpus\n z[i - 1] = best_paths[pos_tag_for_word_i, i]\n \n # Get the previous word's POS tag in string form\n # Use the 'states' list, \n # where the key is the unique integer ID of the POS tag,\n # and the value is the string representation of that POS tag\n pred[i - 1] = states[pos_tag_for_word_i]\n \n ### END CODE HERE ###\n return pred\n\n\n# Run and test your function\npred = viterbi_backward(best_probs, best_paths, prep, states)\nm=len(pred)\nprint('The prediction for pred[-7:m-1] is: \\n', prep[-7:m-1], \"\\n\", pred[-7:m-1], \"\\n\")\nprint('The prediction for pred[0:8] is: \\n', pred[0:7], \"\\n\", prep[0:7])\n\n# **Expected Output:** \n#\n# ```CPP\n# The prediction for pred[-7:m-1] is: \n# ['see', 'them', 'here', 'with', 'us', '.'] \n# ['VB', 'PRP', 'RB', 'IN', 'PRP', '.'] \n# The prediction for pred[0:8] is: \n# ['DT', 'NN', 'POS', 'NN', 'MD', 'VB', 'VBN'] \n# ['The', 'economy', \"'s\", 'temperature', 'will', 'be', 'taken'] \n# ```\n#\n# Now you just have to compare the predicted labels to the true labels to evaluate your model on the accuracy metric!\n\n# <a name='4'></a>\n# # Part 4: Predicting on a data set\n#\n# Compute the accuracy of your prediction by comparing it with the true `y` labels. \n# - `pred` is a list of predicted POS tags corresponding to the words of the `test_corpus`. \n\nprint('The third word is:', prep[3])\nprint('Your prediction is:', pred[3])\nprint('Your corresponding label y is: ', y[3])\n\n\n# <a name='ex-08'></a>\n# ### Exercise 08\n#\n# Implement a function to compute the accuracy of the viterbi algorithm's POS tag predictions.\n# - To split y into the word and its tag you can use `y.split()`. \n\n# UNQ_C8 (UNIQUE CELL IDENTIFIER, DO NOT EDIT)\n# GRADED FUNCTION: compute_accuracy\ndef compute_accuracy(pred, y):\n '''\n Input: \n pred: a list of the predicted parts-of-speech \n y: a list of lines where each word is separated by a '\\t' (i.e. word \\t tag)\n Output: \n \n '''\n num_correct = 0\n total = 0\n \n # Zip together the prediction and the labels\n for prediction, y in zip(pred, y):\n ### START CODE HERE (Replace instances of 'None' with your code) ###\n # Split the label into the word and the POS tag\n word_tag_tuple = y.split()\n \n # Check that there is actually a word and a tag\n # no more and no less than 2 items\n if len(word_tag_tuple) != 2: # complete this line\n continue\n\n # store the word and tag separately\n word, tag = word_tag_tuple\n \n # Check if the POS tag label matches the prediction\n if prediction == tag: # complete this line\n \n # count the number of times that the prediction\n # and label match\n num_correct += 1\n \n # keep track of the total number of examples (that have valid labels)\n total += 1\n \n ### END CODE HERE ###\n return num_correct/total\n\n\nprint(f\"Accuracy of the Viterbi algorithm is {compute_accuracy(pred, y):.4f}\")\n\n# ##### Expected Output\n#\n# ```CPP\n# Accuracy of the Viterbi algorithm is 0.9531\n# ```\n#\n# Congratulations you were able to classify the parts-of-speech with 95% accuracy. \n\n# ### Key Points and overview\n#\n# In this assignment you learned about parts-of-speech tagging. \n# - In this assignment, you predicted POS tags by walking forward through a corpus and knowing the previous word.\n# - There are other implementations that use bidirectional POS tagging.\n# - Bidirectional POS tagging requires knowing the previous word and the next word in the corpus when predicting the current word's POS tag.\n# - Bidirectional POS tagging would tell you more about the POS instead of just knowing the previous word. \n# - Since you have learned to implement the unidirectional approach, you have the foundation to implement other POS taggers used in industry.\n\n# ### References\n#\n# - [\"Speech and Language Processing\", Dan Jurafsky and James H. Martin](https://web.stanford.edu/~jurafsky/slp3/)\n# - We would like to thank Melanie Tosik for her help and inspiration\n"},"script_size":{"kind":"number","value":53979,"string":"53,979"}}},{"rowIdx":82,"cells":{"path":{"kind":"string","value":"/k-nearest Neighbors (kNN).ipynb"},"content_id":{"kind":"string","value":"13928c0db0b312ebfd4e015cc086ba97b32a7885"},"detected_licenses":{"kind":"list like","value":[],"string":"[]","isConversational":false},"license_type":{"kind":"string","value":"no_license"},"repo_name":{"kind":"string","value":"KamingYip/Trading_Strategies_with_Stock_Data_Updating"},"repo_url":{"kind":"string","value":"https://github.com/KamingYip/Trading_Strategies_with_Stock_Data_Updating"},"star_events_count":{"kind":"number","value":0,"string":"0"},"fork_events_count":{"kind":"number","value":0,"string":"0"},"gha_license_id":{"kind":"null"},"gha_event_created_at":{"kind":"null"},"gha_updated_at":{"kind":"null"},"gha_language":{"kind":"null"},"language":{"kind":"string","value":"Jupyter Notebook"},"is_generated":{"kind":"bool","value":false,"string":"false"},"is_vendor":{"kind":"bool","value":false,"string":"false"},"conversion_extension":{"kind":"string","value":".py"},"size":{"kind":"number","value":156730,"string":"156,730"},"script":{"kind":"string","value":"# ---\n# jupyter:\n# jupytext:\n# text_representation:\n# extension: .py\n# format_name: light\n# format_version: '1.5'\n# jupytext_version: 1.15.2\n# kernelspec:\n# display_name: Python 3\n# language: python\n# name: python3\n# ---\n\n# # <div align=\"center\">Data Science with Stock Data - k-nearest Neighbors (kNN)</div>\n# ### <div align=\"center\">Author: <a href=\"https://www.linkedin.com/in/kaming-yip-22b03a1a0/\">Kaming Yip</a>  Date: Feb. 22, 2020</div>\n\n# Before start reading this file, you are suggested to read the project instruction in the <a href=\"https://github.com/KamingYip/Data-Science-with-Stock-Data/blob/master/README.md\">README.md</a> file.\n#\n# In this file, we will implement <b>k-nearest Neighbors (kNN)</b> in our selected stock data, YELP, for two years 2018 and 2019, to predict labels and compute the model performance of trading strategies based on the labels.\n#\n# First, we scrape the historical data from <a href=\"https://finance.yahoo.com/quote/YELP?p=YELP&.tsrc=fin-srch-v1\">yahoo web</a> and manipulate the data to create desirable columns.\n\nfrom pandas_datareader import data as web\nimport pandas as pd\nimport numpy as np\n\n\n# +\ndef get_stock(ticker, start_date, end_date):\n try:\n df = web.get_data_yahoo(ticker, start=start_date, end=end_date)\n df['Return'] = df['Adj Close'].pct_change()\n df['Return'].fillna(0, inplace = True)\n df['Return'] = 100.0 * df['Return']\n df['Return'] = df['Return'].round(3)\n df['Date'] = df.index\n df['Date'] = pd.to_datetime(df['Date'])\n df['Month'] = df['Date'].dt.month\n df['Year'] = df['Date'].dt.year\n df['Day'] = df['Date'].dt.day\n for col in ['Open', 'High', 'Low', 'Close', 'Adj Close']:\n df[col] = df[col].round(2)\n df['Weekday'] = df['Date'].dt.weekday_name \n df['Week_Number'] = df['Date'].dt.strftime('%U')\n df['Year_Week'] = df['Date'].dt.strftime('%Y-%U')\n col_list = ['Date', 'Year', 'Month', 'Day', 'Weekday', 'Week_Number', 'Year_Week',\n 'Open', 'High', 'Low', 'Close', 'Volume', 'Adj Close', 'Return']\n df = df[col_list]\n return df\n except Exception as error:\n print(error)\n return None\n\nticker='YELP'\ndf = get_stock(ticker, start_date='2017-01-01', end_date='2019-12-31')\ndf.head()\n\n\n# -\n\n# Then we will create the mean return and volatility values for each week. These two features will be our main independent variables to train the model.\n\n# +\ndef weekly_return_volatility(data, start_date, end_date):\n df_2 = data[data['Date'] >= start_date]\n df_2 = df_2[df_2['Date'] <= end_date]\n df_2 = df_2[['Year', 'Week_Number', 'Open', 'Adj Close', 'Return']]\n df_2.index = range(len(df_2))\n df_grouped = df_2.groupby(['Year', 'Week_Number'])['Return'].agg([np.mean, np.std])\n df_grouped.reset_index(['Year', 'Week_Number'], inplace=True)\n df_grouped.rename(columns={'mean': 'mean_return', 'std':'volatility'}, inplace=True)\n df_grouped.fillna(0, inplace=True)\n df_grouped[\"Open\"] = df_2.groupby([\"Year\", \"Week_Number\"])[\"Open\"].head(1).\\\n reset_index(drop = True).copy()\n df_grouped[\"Adj Close\"] = df_2.groupby([\"Year\", \"Week_Number\"])[\"Adj Close\"].tail(1).\\\n reset_index(drop = True).copy()\n return df_grouped\n\ndf_weekly = weekly_return_volatility(df, start_date='2018-01-01', end_date='2019-12-31')\ndf_weekly.head()\n\n\n# -\n\n# For each week, we will label as \"green\" or \"red\":\n# * a \"green\" week means that it was a good week to be invested for that week (from Friday to Friday)\n# * a \"red\" week means that it was <b>NOT</b> a good week (e.g. prices fell or there was too much volatility in the price)\n#\n# In this project, we will label those weeks with mean return higher than or equal to the 50-percentile threshold as well as with volatility not higher than the 50-percentile threshold of that year as \"Green\"; otherwise, they will be labeled as \"Red\".\n\n# +\ndef weekly_label(data, year):\n df_label = data[data[\"Year\"] == year].copy()\n mean_return_percent50 = np.percentile(df_label[\"mean_return\"], 50)\n volatility_percent50 = np.percentile(df_label[\"volatility\"], 50) \n df_label[\"True Label\"] = np.where((df_label[\"mean_return\"] >= mean_return_percent50) & \\\n (df_label[\"volatility\"] <= volatility_percent50), \"Green\", \"Red\")\n return df_label\n\ndf_labeling = pd.DataFrame()\nfor year in [2018, 2019]:\n df_year_label = weekly_label(df_weekly, year)\n label_count = df_year_label.groupby(\"True Label\")[\"True Label\"].size().to_frame(name = \"Freq\") \n df_labeling = df_labeling.append(df_year_label, ignore_index = True)\n\ndf_labeling.head()\n# -\n\n# Let's take a look at the label distribution in training data and testing data.\n\n# +\ntrain_df = df_labeling[df_labeling[\"Year\"] == 2018].copy()\ntest_df = df_labeling[df_labeling[\"Year\"] == 2019].copy()\n\ntrain_test_sum = pd.DataFrame({\n \"Dataset\": [\"Training\", \"Testing\", \"Total\"],\n \"Week Num\": [\"{0:,}({1:.2f}%)\".format(len(train_df), len(train_df)/len(df_labeling)*100),\n \"{0:,}({1:.2f}%)\".format(len(test_df), len(test_df)/len(df_labeling)*100),\n \"{0:,}({1:.2f}%)\".format(len(df_labeling), len(df_labeling)/len(df_labeling)*100)],\n \"Green Label\": [\"{0:,}({1:.2f}%)\".format(len(train_df[train_df[\"True Label\"] == \"Green\"]),\n len(train_df[train_df[\"True Label\"] == \"Green\"])/len(train_df)*100),\n \"{0:,}({1:.2f}%)\".format(len(test_df[test_df[\"True Label\"] == \"Green\"]),\n len(test_df[test_df[\"True Label\"] == \"Green\"])/len(test_df)*100),\n \"{0:,}({1:.2f}%)\".format(len(df_labeling[df_labeling[\"True Label\"] == \"Green\"]),\n len(df_labeling[df_labeling[\"True Label\"] == \"Green\"])/len(df_labeling)*100)],\n \"Red Label\": [\"{0:,}({1:.2f}%)\".format(len(train_df[train_df[\"True Label\"] == \"Red\"]),\n len(train_df[train_df[\"True Label\"] == \"Red\"])/len(train_df)*100),\n \"{0:,}({1:.2f}%)\".format(len(test_df[test_df[\"True Label\"] == \"Red\"]),\n len(test_df[test_df[\"True Label\"] == \"Red\"])/len(test_df)*100),\n \"{0:,}({1:.2f}%)\".format(len(df_labeling[df_labeling[\"True Label\"] == \"Red\"]),\n len(df_labeling[df_labeling[\"True Label\"] == \"Red\"])/len(df_labeling)*100)]})\n\ntrain_test_sum\n# -\n\n# By far, we have completed the data preparation. From the raw data, we have conducted feature engineering to create new features that we would use in the modeling, calculated the average return and volatility for each week, and labeled each week as \"Green\" or \"Red\" by a predetermined rule. We will then use the labeled dataset in the following sections.\n#\n# We will first define our confusion matrix function to better visualize the model performance, including Accuracy, Recall, Precision, and F1 score.\n\nfrom tabulate import tabulate\nimport itertools\nfrom sklearn.metrics import confusion_matrix, accuracy_score, recall_score, precision_score, f1_score\n\n\ndef designed_confusion_matrix(train_actual, train_pred, train_title,\n test_actual, test_pred, test_title, classes):\n fig = plt.figure(figsize = (8, 5))\n \n fig.add_subplot(221)\n train_cm = confusion_matrix(train_actual, train_pred)\n plt.imshow(train_cm, interpolation = \"nearest\", cmap = \"Reds\")\n plt.title(train_title)\n plt.colorbar()\n tick_marks = np.arange(len(classes))\n plt.xticks(tick_marks, classes, rotation = 45)\n plt.yticks(tick_marks, classes)\n for i, j in itertools.product(range(train_cm.shape[0]), range(train_cm.shape[1])):\n plt.text(j, i, format(train_cm[i, j], \"d\"), horizontalalignment = \"center\", color = \"black\")\n plt.tight_layout()\n plt.ylabel(\"Actual Class\") \n plt.xlabel(\"Predicted Class\")\n \n fig.add_subplot(222)\n test_cm = confusion_matrix(test_actual, test_pred)\n plt.imshow(test_cm, interpolation = \"nearest\", cmap = \"Reds\")\n plt.title(test_title)\n plt.colorbar()\n tick_marks = np.arange(len(classes))\n plt.xticks(tick_marks, classes, rotation = 45)\n plt.yticks(tick_marks, classes)\n for i, j in itertools.product(range(test_cm.shape[0]), range(test_cm.shape[1])):\n plt.text(j, i, format(test_cm[i, j], \"d\"), horizontalalignment = \"center\", color = \"black\")\n plt.tight_layout()\n plt.ylabel(\"Actual Class\")\n plt.xlabel(\"Predicted Class\")\n plt.show()\n \n stats_summary = pd.DataFrame(columns = [\"Training Data\", \"Testing Data\"],\n index = [\"Accuracy\", \"Recall\", \"Precision\", \"F1 Score\"])\n stats_set = [[train_actual, train_pred], [test_actual, test_pred]]\n for i, ele in enumerate(stats_set):\n stats_summary.iloc[:, i] = [accuracy_score(ele[0], ele[1]),\n recall_score(ele[0], ele[1]),\n precision_score(ele[0], ele[1]),\n f1_score(ele[0], ele[1])]\n print(tabulate(stats_summary, headers = \"keys\", numalign = \"right\", floatfmt = \".3f\"), end = \"\\n\\n\")\n\n\n# The kNN model will be trained by stock data in 2018 and several k values will be tested against the training data and computed the accuracy of the kNN classifier.\n\nfrom sklearn.preprocessing import StandardScaler, LabelEncoder\nfrom sklearn.neighbors import KNeighborsClassifier\nfrom sklearn.metrics import accuracy_score\nimport matplotlib.pyplot as plt\n\nX_train = train_df[[\"mean_return\", \"volatility\"]].values\nkNN_scaler = StandardScaler().fit(X_train)\nX_train = kNN_scaler.transform(X_train)\ny_train = train_df[\"True Label\"].values\nle = LabelEncoder().fit(y_train)\ny_train = le.transform(y_train)\n\n# +\nk_values = list(range(3, 17, 2))\n\nmax_accuracy = 0.0\naccuracy_list = []\n\nfor k in k_values:\n kNN_classifier = KNeighborsClassifier(n_neighbors = k).fit(X_train, y_train)\n y_train_pred = kNN_classifier.predict(X_train)\n accuracy = accuracy_score(y_train, y_train_pred)\n accuracy_list.append(accuracy)\n if accuracy >= max_accuracy:\n max_accuracy = accuracy\n\noptimal_k_dict = {k:accuracy for (k, accuracy) in enumerate(accuracy_list) if accuracy == max_accuracy}\noptimal_k_list = [k_values[i] for i in optimal_k_dict.keys()]\n\nplt.figure(figsize = (6, 4))\nplt.plot(k_values, accuracy_list, color = \"black\", marker = \"o\",\n markerfacecolor = \"red\", markersize = 10)\nplt.title(\"Accuracy Rate against Different k Values\")\nplt.xlabel(\"k Values\")\nplt.xticks(k_values)\nplt.ylabel(\"Accuracy\")\nplt.show()\n# -\n\n# As shown in the graph above, the accuracy reaches to its peak as 96.23% when k = 3 and k = 5. Next, we will take these two k values to test the model performance against testing data and choose the optimal one.\n\n# +\nX_test = test_df[[\"mean_return\", \"volatility\"]].values\nX_test = kNN_scaler.transform(X_test)\ny_test = test_df[\"True Label\"].values\ny_test = le.transform(y_test)\n\nfor k in optimal_k_list:\n kNN_classifier = KNeighborsClassifier(n_neighbors = k).fit(X_train, y_train)\n y_train_pred = kNN_classifier.predict(X_train)\n y_test_pred = kNN_classifier.predict(X_test)\n designed_confusion_matrix(y_train, y_train_pred, \"The Confusion Matrix\\nfor the Training Data (k = {0})\".format(k),\n y_test, y_test_pred, \"The Confusion Matrix\\nfor the Testing Data (k = {0})\".format(k),\n [\"Green\", \"Red\"])\n\n\n# -\n\n# The two sets of confusion matrix indicate that the kNN models built with k = 3 and k = 5 perform outstandingly against the training data, as well as the testing data. The accuracy of the models is satisfied when they met with unseen data (i.e. the testing data) and the model built with k = 3 slightly outperforms the other one.\n#\n# It is worth noting that, in k-nearest Neighbors model, the advantage of choosing k > 1 is that higher values of k provide smoothing that reduces the risk of overfitting due to noise in the training data. Generally speaking, choosing smaller values for k can be noisy and will have a higher influence on the result; however, if k is too high, we will miss out the method's ability to capture the local structure in the data, also computationally expensive. One of the extreme cases would be k = N, where N is the number of records. In this instance, no matter what features the new record will have, the larger-number group in the training data will always win, which will be majority rule in a binary case.\n#\n# Therefore, taking all the reasons into consideration, we will choose <b>k = 3</b> as our final decision and implement the trading strategy by the labels created by the kNN model when k = 3.\n\n# +\ndef trade_with_labels(data, col_name):\n money = 100.0\n shares = 0.0\n position = \"No\"\n balance = []\n df_trade_labels = data.copy()\n for i in range(len(df_trade_labels) - 1):\n if i == 0:\n label = df_trade_labels.iloc[i][col_name]\n if label == \"Green\":\n shares = money / df_trade_labels.iloc[i][\"Open\"]\n money = 0.0\n position = \"Long\"\n balance.append(shares * df_trade_labels.iloc[i][\"Adj Close\"])\n else:\n balance.append(money) \n else:\n label = df_trade_labels.iloc[i+1][col_name]\n if label == \"Red\":\n if position == \"Long\":\n money = shares * df_trade_labels.iloc[i][\"Adj Close\"]\n shares = 0.0\n position = \"No\"\n balance.append(money)\n else:\n if position == \"No\":\n shares = money / df_trade_labels.iloc[i+1][\"Open\"]\n money = 0.0\n position = \"Long\"\n balance.append(shares * df_trade_labels.iloc[i][\"Adj Close\"]) \n if position == \"Long\":\n balance.append(shares * df_trade_labels.iloc[-1][\"Adj Close\"])\n else:\n balance.append(money)\n return balance\n\ndef script_text(data, year, col_name):\n label_text_max = \"{0} Week {1}\\nmax ${2}\".\\\n format(year, data.iloc[data[data[\"Year\"] == year][col_name].idxmax()][\"Week_Number\"],\n round(data[data[\"Year\"] == year][col_name].max(), 2))\n label_x_max = data[data[\"Year\"] == year][col_name].idxmax()\n label_y_max = round(data[data[\"Year\"] == year][col_name].max(), 2)\n \n label_text_min = \"{0} Week {1}\\nmin ${2}\".\\\n format(year,\n data.iloc[data[data[\"Year\"] == year][col_name].idxmin()][\"Week_Number\"],\n round(data[data[\"Year\"] == year][col_name].min(), 2))\n label_x_min = data[data[\"Year\"] == year][col_name].idxmin()\n label_y_min = round(data[data[\"Year\"] == year][col_name].min(), 2)\n \n label_text_final = \"{0} Final:\\n${1}\".format(year, round(data[data[\"Year\"] == year].iloc[-1][col_name], 2))\n label_x_final = data[data[\"Year\"] == year].tail(1).index.values\n label_y_final = round(data[data[\"Year\"] == year].iloc[-1][col_name], 2)\n \n return label_text_max, label_x_max, label_y_max,\\\n label_text_min, label_x_min, label_y_min,\\\n label_text_final, label_x_final, label_y_final\n\ndef buy_n_hold(data):\n money = 100.0\n shares = 0.0\n balance = []\n df_buy_hold = data.copy() \n for i in range(len(df_buy_hold)):\n if i == 0:\n shares = money / df_buy_hold.iloc[i][\"Open\"]\n balance.append(shares * df_buy_hold.iloc[i][\"Adj Close\"])\n return balance\n\n\n# +\ndf_trading = df_labeling[df_labeling[\"Year\"] == 2019].copy().reset_index(drop = True)\ndf_trading[\"True Label Balance\"] = trade_with_labels(df_trading, \"True Label\")\ndf_trading[\"Buy and Hold Balance\"] = buy_n_hold(df_trading)\n\nk = 3\nkNN_classifier = KNeighborsClassifier(n_neighbors = k).fit(X_train, y_train)\ny_test_pred = kNN_classifier.predict(X_test)\ndf_trading[\"kNN Label(k = {0})\".format(k)] = le.inverse_transform(y_test_pred)\ndf_trading[\"kNN Balance(k = {0})\".format(k)] = trade_with_labels(df_trading, \"kNN Label(k = {0})\".format(k))\n\nfig, ax = plt.subplots(figsize = (9, 5))\n \nlabel_text_max_2019, label_x_max_2019, label_y_max_2019,\\\n label_text_min_2019, label_x_min_2019, label_y_min_2019,\\\n label_text_final_2019, label_x_final_2019, label_y_final_2019 =\\\n script_text(df_trading, 2019, \"True Label Balance\")\n \nbuy_hold_text_max_2019, buy_hold_x_max_2019, buy_hold_y_max_2019,\\\n buy_hold_text_min_2019, buy_hold_x_min_2019, buy_hold_y_min_2019,\\\n buy_hold_text_final_2019, buy_hold_x_final_2019, buy_hold_y_final_2019 =\\\n script_text(df_trading, 2019, \"Buy and Hold Balance\")\n \nkNN_text_max_2019, kNN_x_max_2019, kNN_y_max_2019,\\\n kNN_text_min_2019, kNN_x_min_2019, kNN_y_min_2019,\\\n kNN_text_final_2019, kNN_x_final_2019, kNN_y_final_2019 =\\\n script_text(df_trading, 2019, \"kNN Balance(k = {0})\".format(k))\n\n# Trading with True Labels\nax.plot(df_trading.index, \"True Label Balance\", data = df_trading, color = \"blue\")\n \nax.annotate(label_text_max_2019, xy = (label_x_max_2019, label_y_max_2019), xycoords = \"data\",\n xytext = (label_x_max_2019+5, label_y_max_2019+5), color = \"blue\",\n arrowprops = dict(arrowstyle = \"->\", connectionstyle = \"angle,angleA=0,angleB=90\", color = \"blue\"),\n ha = \"left\", va = \"bottom\")\nax.annotate(label_text_min_2019, xy = (label_x_min_2019, label_y_min_2019), xycoords = \"data\",\n xytext = (label_x_min_2019+5, label_y_min_2019+17), color = \"blue\",\n arrowprops = dict(arrowstyle = \"->\", connectionstyle = \"angle,angleA=0,angleB=90\", color = \"blue\"),\n ha = \"left\", va = \"bottom\")\nax.annotate(label_text_final_2019, xy = (label_x_final_2019, label_y_final_2019), xycoords = \"data\",\n xytext = (label_x_final_2019+5, label_y_final_2019-5), color = \"blue\",\n arrowprops = dict(arrowstyle = \"->\", connectionstyle = \"angle,angleA=0,angleB=90\", color = \"blue\"),\n ha = \"left\", va = \"bottom\")\n \n# Buy and Hold\nax.plot(df_trading.index, \"Buy and Hold Balance\", data = df_trading, color = \"red\")\n \nax.annotate(buy_hold_text_max_2019, xy = (buy_hold_x_max_2019, buy_hold_y_max_2019), xycoords = \"data\",\n xytext = (buy_hold_x_max_2019+5, buy_hold_y_max_2019+15), color = \"red\",\n arrowprops = dict(arrowstyle = \"->\", connectionstyle = \"angle,angleA=0,angleB=90\", color = \"red\"),\n ha = \"left\", va = \"bottom\")\nax.annotate(buy_hold_text_min_2019, xy = (buy_hold_x_min_2019, buy_hold_y_min_2019), xycoords = \"data\",\n xytext = (buy_hold_x_min_2019+4, buy_hold_y_min_2019+2), color = \"red\",\n arrowprops = dict(arrowstyle = \"->\", connectionstyle = \"angle,angleA=0,angleB=90\", color = \"red\"),\n ha = \"left\", va = \"bottom\")\nax.annotate(buy_hold_text_final_2019, xy = (buy_hold_x_final_2019, buy_hold_y_final_2019), xycoords = \"data\",\n xytext = (buy_hold_x_final_2019+5, buy_hold_y_final_2019-2), color = \"red\",\n arrowprops = dict(arrowstyle = \"->\", connectionstyle = \"angle3\", color = \"red\"),\n ha = \"left\", va = \"bottom\")\n \n# kNN Labels\nax.plot(df_trading.index, \"kNN Balance(k = {0})\".format(k), data = df_trading, color = \"green\")\n \nax.annotate(kNN_text_max_2019, xy = (kNN_x_max_2019, kNN_y_max_2019), xycoords = \"data\",\n xytext = (kNN_x_max_2019+5, kNN_y_max_2019+10), color = \"green\",\n arrowprops = dict(arrowstyle = \"->\", connectionstyle = \"angle,angleA=0,angleB=90\", color = \"green\"),\n ha = \"left\", va = \"bottom\")\nax.annotate(kNN_text_min_2019, xy = (kNN_x_min_2019, kNN_y_min_2019), xycoords = \"data\",\n xytext = (kNN_x_min_2019+5, kNN_y_min_2019+25), color = \"green\",\n arrowprops = dict(arrowstyle = \"->\", connectionstyle = \"angle,angleA=0,angleB=90\", color = \"green\"),\n ha = \"left\", va = \"bottom\")\nax.annotate(kNN_text_final_2019, xy = (kNN_x_final_2019, kNN_y_final_2019), xycoords = \"data\",\n xytext = (kNN_x_final_2019+5, kNN_y_final_2019-2), color = \"green\",\n arrowprops = dict(arrowstyle = \"->\", connectionstyle = \"angle,angleA=0,angleB=90\", color = \"green\"),\n ha = \"left\", va = \"bottom\")\n\nplt.title(\"* Year 2019 *\\n\" + \"Performance against Different Investing Strategies\", loc = \"center\")\nplt.xlabel(\"Week Number\")\nplt.xticks(np.arange(0, 60, 5))\nplt.ylabel(\"Total Balance($)\")\nplt.legend()\nplt.show()\n# -\n\n# As displayed in the plot above, the kNN strategy results in the largest amount as $155.93 at the end of year 2019 when we start with $100 at the begining of the year.\n#\n# The buy-and-hold strategy refers that we invest $100 on the first trading day (at the opening price) and sell at the last trading day of the year at the adjusted closing price. For this strategy, we end up with $101.87 at the end of the year.\n#\n# Lastly, if we trade with the true labels, we can earn $137.54 at the end. By analyzing the differences between the three strategies, we can learn that the kNN model predicts some weeks (especially between Week 25 and Week 40) as \"good\" weeks to be invested and labels those weeks as \"Green\" when they are actually labeled as \"Red\" by our labeling rule. Although the kNN model did not perfectly predict the labels, it provides better trading strategy for us to trade stock, which is an interesting finding from this assignment.\n"},"script_size":{"kind":"number","value":21771,"string":"21,771"}}},{"rowIdx":83,"cells":{"path":{"kind":"string","value":"/Data Visualization.ipynb"},"content_id":{"kind":"string","value":"a17d8f03decc66845d662dad998b494f88e0f507"},"detected_licenses":{"kind":"list like","value":[],"string":"[]","isConversational":false},"license_type":{"kind":"string","value":"no_license"},"repo_name":{"kind":"string","value":"Vishal425/Data-Visualization"},"repo_url":{"kind":"string","value":"https://github.com/Vishal425/Data-Visualization"},"star_events_count":{"kind":"number","value":0,"string":"0"},"fork_events_count":{"kind":"number","value":0,"string":"0"},"gha_license_id":{"kind":"null"},"gha_event_created_at":{"kind":"null"},"gha_updated_at":{"kind":"null"},"gha_language":{"kind":"null"},"language":{"kind":"string","value":"Jupyter Notebook"},"is_generated":{"kind":"bool","value":false,"string":"false"},"is_vendor":{"kind":"bool","value":false,"string":"false"},"conversion_extension":{"kind":"string","value":".py"},"size":{"kind":"number","value":106309,"string":"106,309"},"script":{"kind":"string","value":"# ---\n# jupyter:\n# jupytext:\n# text_representation:\n# extension: .py\n# format_name: light\n# format_version: '1.5'\n# jupytext_version: 1.15.2\n# kernelspec:\n# display_name: Python 3\n# language: python\n# name: python3\n# ---\n\nimport matplotlib.pyplot as plt\n#Array, list, Tupples and pandas series\nimport seaborn as sns\n#DataFrame\nimport numpy as np\nimport pandas as pd\n\nyear = [2015,2016,2017,2018,2019]\nsales = [1234,4344,4454,3222,3343]\nprofit = [223,334,352,333,434]\n\nplt.plot(year,sales)\n\nplt.plot(year,sales,'red')\nplt.xlabel('Year')\nplt.ylabel('Sales and Profit')\nplt.plot(year,profit,'blue')\nplt.title('Sales and Profit by Year')\nplt.show()\n\nplt.axes([0.05,0.05,0.9,0.9])\nplt.plot(year,sales,'red')\nplt.xlabel('Year')\nplt.ylabel('Sales')\nplt.title('Sales Vs Year')\nplt.axes([1.1,0.05,0.9,0.9])\nplt.plot(year,profit,'blue')\nplt.xlabel('Year')\nplt.ylabel('Profit')\nplt.title('Profir Vs Sales')\n\nplt.subplot(2,1,1)\nplt.plot(year,sales,'red')\nplt.xlabel('Year')\nplt.ylabel('Sales')\nplt.title('Sales Vs Year')\nplt.subplot(2,1,2)\nplt.plot(year,profit,'blue')\nplt.xlabel('Year')\nplt.ylabel('Profit')\nplt.title('Profir Vs Sales')\nplt.tight_layout()\n\nplt.plot(year,sales,'red')\nplt.xlim(2017,2018)\nplt.ylim(4000,4500)\n\nplt.plot(year,sales,'brown')\nplt.axis((2017,2018,4000,4500))\n\nplt.scatter(x=sales,y=profit,marker='+',label='sales vs profit')\nplt.legend(loc=0)\nplt.annotate('customer1',xy=(3343,333))\nplt.style.use('seaborn-darkgrid')\n\nprint(plt.style.available)\n\nsales\n\nprofit\n\n\n"},"script_size":{"kind":"number","value":1522,"string":"1,522"}}},{"rowIdx":84,"cells":{"path":{"kind":"string","value":"/42_rnn_seq2seq_colab.ipynb"},"content_id":{"kind":"string","value":"d1a50d0108da80ccda2ed43a3c539861412ac46c"},"detected_licenses":{"kind":"list like","value":[],"string":"[]","isConversational":false},"license_type":{"kind":"string","value":"no_license"},"repo_name":{"kind":"string","value":"gubosd/lecture18"},"repo_url":{"kind":"string","value":"https://github.com/gubosd/lecture18"},"star_events_count":{"kind":"number","value":1,"string":"1"},"fork_events_count":{"kind":"number","value":2,"string":"2"},"gha_license_id":{"kind":"null"},"gha_event_created_at":{"kind":"null"},"gha_updated_at":{"kind":"null"},"gha_language":{"kind":"null"},"language":{"kind":"string","value":"Jupyter Notebook"},"is_generated":{"kind":"bool","value":false,"string":"false"},"is_vendor":{"kind":"bool","value":false,"string":"false"},"conversion_extension":{"kind":"string","value":".py"},"size":{"kind":"number","value":80566,"string":"80,566"},"script":{"kind":"string","value":"# ---\n# jupyter:\n# jupytext:\n# text_representation:\n# extension: .py\n# format_name: light\n# format_version: '1.5'\n# jupytext_version: 1.15.2\n# kernelspec:\n# display_name: Python 3\n# language: python\n# name: python3\n# ---\n\n# + [markdown] id=\"h_GAwHdc1_fH\"\n# ## 자연어 처리 딥러닝\n# # Seq2seq : 영어-불어 번역기\n\n# + [markdown] id=\"8DgZT-mi1_fv\"\n# - http://keras.io/examples/lstm_seq2seq/\n# - 데이타 : http://www.manythings.org/anki/fra-eng.zip\n\n# + [markdown] id=\"cFZLgrwB1_gJ\"\n# <img src='https://www.d2l.ai/_images/seq2seq.svg' />\n# (출처: https://www.d2l.ai/chapter_recurrent-neural-networks/seq2seq.html)\n\n# + [markdown] id=\"v3s2tVzL1_gL\"\n# - Encoder 와 Decoder 두 개의 모델을 만든고 연결한다.\n# - Encoder 는 최종 상태값을 Decoder 에게 넘긴다. (Decoder 의 초기 상태입력값이 된다.)\n# - Decoder 의 목표값은 불어 문장에서 한 단어씩 밀린 문장이다. (최종 출력 문장과 비교하여 손실값 계산)\n# - Seq2seq 는 번역과 같이 쌍으로 된 문장들에 적용한다. => 문장 생성용으로 챗봇 또는 Q/A 등에 사용된다.\n\n# + id=\"hunoWrRb1_ga\"\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport pandas as pd\n\nfrom tensorflow import keras\n\n# + colab={\"base_uri\": \"https://localhost:8080/\"} id=\"yqKCo2Ou2RS6\" outputId=\"22afd8a1-5bff-4dfb-c2d1-420dca6ce0c1\"\nfrom google.colab import drive\ndrive.mount('/content/drive')\n\n# + colab={\"base_uri\": \"https://localhost:8080/\"} id=\"-0SaN8WX2Qsu\" outputId=\"79004d4c-8457-4a35-a54f-4cb6e9191d0b\"\n# ! ls /content/drive/MyDrive/*.txt\n\n# + id=\"hBKKKUCj1_ge\"\nwith open('/content/drive/MyDrive/fra.txt', encoding='utf-8') as f:\n lines = f.read().split('\\n')\n\n# + colab={\"base_uri\": \"https://localhost:8080/\", \"height\": 283} id=\"ZwwR75sJ1_gj\" outputId=\"9d714250-3197-4fad-89ec-e90498df7131\"\ndisplay(len(lines), lines[:10], lines[-3:])\n\n# + [markdown] id=\"ivuLTKe-1_g5\"\n# - 총 라인수는 149,862개 임\n# - 탭으로 구분됨 => '영어문장\\t불어문장'\n# - 마지막 라인은 공백임\n# - 이 중 10,000 라인만 사용할 것임\n\n# + id=\"ZQfphmEX1_hJ\"\ninput_texts = []\noutput_texts = []\n\ninput_chars = set()\noutput_chars = set()\n\nfor line in lines[:10000]:\n s1, s2 = line.split('\\t')\n s2 = '\\t' + s2 + '\\n' # 앞에는 탭, 뒤에는 개행문자를 붙인다\n input_texts.append(s1)\n output_texts.append(s2) \n \n for c1 in s1:\n input_chars.add(c1)\n \n for c2 in s2:\n output_chars.add(c2)\n \ninput_chars = sorted(list(input_chars))\noutput_chars = sorted(list(output_chars))\n\n# + colab={\"base_uri\": \"https://localhost:8080/\"} id=\"7ebU3rz61_hR\" outputId=\"c3b6f5b6-be4c-4130-b34b-e78300dae115\"\nlen(input_texts), len(output_texts), len(input_chars), len(output_chars)\n\n# + [markdown] id=\"1aFzivCA1_hn\"\n# ### 단어 사전 (토큰)\n\n# + colab={\"base_uri\": \"https://localhost:8080/\"} id=\"QOFKxUI81_hr\" outputId=\"5ee9ebd5-d7c5-4b5f-a1d2-2bf2feaf5635\"\nlen(input_chars), len(output_chars) # 71, 94\n\n# + colab={\"base_uri\": \"https://localhost:8080/\"} id=\"zz4bneCP1_h_\" outputId=\"2d4ecbeb-7400-43f8-9170-fd85bf05d343\"\nprint(input_chars)\nprint(output_chars)\n\n# + [markdown] id=\"dJ3B1MOv1_iH\"\n# ### 시퀀스 만들기\n\n# + id=\"LMYnBkbo1_iM\"\nmax_input_len = max([len(s) for s in input_texts]) # 16\nmax_output_len = max([len(s) for s in output_texts]) # 59\n\n# + colab={\"base_uri\": \"https://localhost:8080/\"} id=\"ylXL6Qi11_iP\" outputId=\"400f6d14-f682-4ba5-c767-dfcb9275a0ee\"\nmax_input_len, max_output_len\n\n# + id=\"m4V-O2vB1_iz\"\nenc_in_data = np.zeros([10000, max_input_len, len(input_chars)]) # (10000,16,71)\ndec_in_data = np.zeros([10000, max_output_len, len(output_chars)]) # (10000,59,94)\ndec_out_data = np.zeros([10000, max_output_len, len(output_chars)]) # (10000,59,94)\n\n# + id=\"f0-SuMOb1_jI\"\nfor i, (s1, s2) in enumerate(zip(input_texts, output_texts)):\n for j, c1 in enumerate(s1):\n enc_in_data[i, j, input_chars.index(c1)] = 1\n \n for j, c2 in enumerate(s2):\n dec_in_data[i, j, output_chars.index(c2)] = 1\n if j>0:\n dec_out_data[i, j-1, output_chars.index(c2)] = 1\n\n# + colab={\"base_uri\": \"https://localhost:8080/\"} id=\"2HI_PvsB1_jX\" outputId=\"6410aa04-81ef-478a-cc4a-dfa400f3d38f\"\nenc_in_data.shape, dec_in_data.shape, dec_out_data.shape\n\n# + [markdown] id=\"g2Sb5jyC1_jb\"\n# ### 데이터 설명\n# - enc_in_data (10000,16,71)\n# - 인코더에 들어가는 영어 시퀀스들\n# - 시퀀스는 16개의 토큰으로 되어 있고, 한 토큰은 영어 71개 문자 원핫인코딩\n# - dec_in_data (10000,59,94)\n# - 디코더에 들어가는 불어 시퀀스들\n# - 시퀀스는 59개의 토큰으로 되어 있고, 한 토큰은 불어 94개 문자 원핫인코딩\n# - 첫번째 문자는 '\\t', 마지막 문자는 '\\n'\n# - dec_out_data (10000,59,94)\n# - 디코더에서 출력되는 불어 시퀀스들\n# - dec_in_data 에서 한 토큰씩 밀린 데이터\n# - 마지막 문자는 '\\n'\n\n# + [markdown] id=\"PbqGxE071_je\"\n# ### Encoder/Decoder 정의\n# - 함수형 API : https://keras.io/getting-started/functional-api-guide/\n\n# + id=\"24bJr1nN1_jf\"\nfrom tensorflow.keras.models import Model\nfrom tensorflow.keras.layers import Input, LSTM, Dense\n\n# + id=\"9qb6_n3Z1_jl\"\nenc_input = Input(shape=(None,71))\n\nenc_lstm = LSTM(256, return_state=True)\nenc_output, enc_h, enc_c = enc_lstm(enc_input)\n\nenc_states = [enc_h, enc_c]\n\n# + id=\"5ErwmPUP1_jn\"\ndec_input = Input(shape=(None,94))\n\ndec_lstm = LSTM(256, return_sequences=True, return_state=True)\ndec_outputs, _, _ = dec_lstm(dec_input, initial_state=enc_states) # (59,256)\n\ndec_dense = Dense(94, activation='softmax')\ndec_outputs = dec_dense(dec_outputs) # 각 LSTM 쉘의 출력을 256 => 94 으로 변환 => (59,94)\n\n# + id=\"hYLSxcPM1_jp\"\nmodel = Model(inputs=[enc_input, dec_input], outputs=dec_outputs)\n\n# + colab={\"base_uri\": \"https://localhost:8080/\"} id=\"KvSq6PpJ1_jr\" outputId=\"01b428a2-7d42-4408-c7e1-b614e450b8f3\"\nmodel.summary()\n\n# + id=\"ilcOE5Bj1_jt\"\nmodel.compile(loss='categorical_crossentropy', optimizer='rmsprop', metrics=['acc'])\n\n# + colab={\"base_uri\": \"https://localhost:8080/\"} id=\"IH37PQpw1_jv\" outputId=\"50e56100-c563-496f-ef80-ff6383d7df67\"\nh = model.fit([enc_in_data, dec_in_data], dec_out_data,\n batch_size=64, epochs=100, validation_split=0.2)\n\n# + id=\"zmQXw0_21_jx\"\nmodel.save('eng_fra_model_colab.h5')\n\n# + id=\"Z9RRbafX4epT\"\n# ! cp eng_fra_model_colab.h5 /content/drive/MyDrive/\n\n# + id=\"Nawnx6zVEw8X\"\n\n\n# + colab={\"base_uri\": \"https://localhost:8080/\", \"height\": 282} id=\"z3eV5btt1_jz\" outputId=\"8ebc1b5c-f9e5-4781-d89d-54bfbe284c5f\"\nplt.plot(h.history['loss'], 'b-')\nplt.plot(h.history['val_loss'], 'r-')\nplt.legend(['loss','val_loss'])\n\n# + colab={\"base_uri\": \"https://localhost:8080/\", \"height\": 282} id=\"6L8cD_vI6U2s\" outputId=\"48cd570a-c781-4ca3-9bd7-375e3e952a9a\"\nplt.plot(h.history['acc'], 'b-')\nplt.plot(h.history['val_acc'], 'r-')\nplt.legend(['acc','val_acc'])\n\n# + [markdown] id=\"1r608Xi31_kh\"\n# ### 번역 실행\n\n# + id=\"z8ZlNX6B1_kj\"\nenc_model = Model(enc_input, enc_states)\n\n# + id=\"tZuUUBxvChsM\"\n\n\n# + id=\"_0ePkwfS1_kk\"\ndec_input_h = Input(shape=(256,))\ndec_input_c = Input(shape=(256,))\ndec_states_input = [dec_input_h, dec_input_c]\n\n# + id=\"9NQlkwcq1_kn\"\ndec_outputs, dec_h, dec_c = dec_lstm(dec_input, initial_state=dec_states_input)\ndec_states = [dec_h, dec_c]\n\ndec_outputs2 = dec_dense(dec_outputs)\n\ndec_model = Model([dec_input] + dec_states_input, [dec_outputs2] + dec_states)\n\n\n# + [markdown] id=\"2djp1-wI1_kp\"\n# ### 출력 테스트\n\n# + id=\"Ormvf9hU1_lT\"\ndef decode_sequence(seq):\n states_value = enc_model.predict(seq)\n \n output_seq = np.zeros([1,1,94]) # 94 는 불어사전 문자수\n output_seq[0,0,output_chars.index('\\t')] = 1 # 첫번째 입력문자를 '\\t' 로 설정\n \n stop = False\n result = ''\n \n while not stop:\n output_tokens, h, c = dec_model.predict([output_seq] + states_value)\n result += output_chars[np.argmax(output_tokens[0,-1,:])]\n \n if (result[-1]=='\\n' or len(result)>=59): # 59는 불어 문장 최대 길이\n stop = True\n \n output_seq = np.zeros([1,1,94]) # 94 는 불어사전 문자수\n output_seq[0,0,np.argmax(output_tokens[0,-1])] = 1\n states_value = [h,c]\n \n return result\n\n\n# + colab={\"base_uri\": \"https://localhost:8080/\"} id=\"9CfXkYQt1_lh\" outputId=\"893cae19-e990-43f8-d0f1-adb5093133c4\"\nfor i in range(2):\n seq = enc_in_data[5000+i:5000+i+1]\n result = decode_sequence(seq)\n \n print('################################')\n print(input_texts[5000+i])\n print('=>')\n print(result)\n\n# + colab={\"base_uri\": \"https://localhost:8080/\"} id=\"SX7PtOqm1_lk\" outputId=\"72dcaf78-1a56-4cf4-dde0-bdb38acc7879\"\nstart = 7000\nfor i in range(3):\n seq = enc_in_data[start+i:start+i+1]\n result = decode_sequence(seq)\n \n print('################################')\n print(input_texts[start+i])\n print(output_texts[start+i][1:-1])\n print('=>')\n #print('[%s]' % result.replace(' ','_'))\n print('[%s]' % result)\n\n# + [markdown] id=\"ndgWHV3j1_ln\"\n# ### 새로운 문장으로 테스트\n\n# + colab={\"base_uri\": \"https://localhost:8080/\", \"height\": 72} id=\"FOSRZvF21_lo\" outputId=\"9893fc8e-fd01-4d6b-b447-222e92c4e956\"\n#s1, s2 = lines[10010].strip().split('\\t')\ns1 = 'I want to go home.'\ns2 = ''\nv = [input_chars.index(c) for c in s1]\n\na = np.zeros([1,30,71])\nfor i in range(len(v)):\n a[0,i,v[i]] = 1\n \nr = decode_sequence(a)\ndisplay(s1, s2, r[:-1])\n"},"script_size":{"kind":"number","value":8750,"string":"8,750"}}},{"rowIdx":85,"cells":{"path":{"kind":"string","value":"/03_Audio_Data_Model_MFCC.ipynb"},"content_id":{"kind":"string","value":"c10a12727707eb8504efe4556a906a68a4b85d4f"},"detected_licenses":{"kind":"list like","value":["LicenseRef-scancode-unknown-license-reference","Apache-2.0"],"string":"[\n \"LicenseRef-scancode-unknown-license-reference\",\n \"Apache-2.0\"\n]","isConversational":false},"license_type":{"kind":"string","value":"permissive"},"repo_name":{"kind":"string","value":"ryanbales/Audio-Data-Insights"},"repo_url":{"kind":"string","value":"https://github.com/ryanbales/Audio-Data-Insights"},"star_events_count":{"kind":"number","value":10,"string":"10"},"fork_events_count":{"kind":"number","value":3,"string":"3"},"gha_license_id":{"kind":"string","value":"Apache-2.0"},"gha_event_created_at":{"kind":"timestamp","value":"2022-11-21T21:23:27","string":"2022-11-21T21:23:27"},"gha_updated_at":{"kind":"timestamp","value":"2020-10-24T20:07:22","string":"2020-10-24T20:07:22"},"gha_language":{"kind":"string","value":"Jupyter Notebook"},"language":{"kind":"string","value":"Jupyter Notebook"},"is_generated":{"kind":"bool","value":false,"string":"false"},"is_vendor":{"kind":"bool","value":false,"string":"false"},"conversion_extension":{"kind":"string","value":".py"},"size":{"kind":"number","value":89395,"string":"89,395"},"script":{"kind":"string","value":"# ---\n# jupyter:\n# jupytext:\n# text_representation:\n# extension: .py\n# format_name: light\n# format_version: '1.5'\n# jupytext_version: 1.15.2\n# kernelspec:\n# display_name: Python 3\n# language: python\n# name: python3\n# ---\n\n# # Building an Audio Data Model using MFCC Features\n\n# #### Ryan Bales (@ryanbales)<br>ryan@balesofdata.com\n\n# ***\n\n# ### Import Packages\n\nimport librosa\nimport librosa.display\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport pandas as pd\nimport os\nimport keras\nfrom keras.models import Sequential\nfrom keras.layers import Dense, Dropout, Flatten\nfrom keras.layers import BatchNormalization\nfrom keras.layers import LSTM\n\n# #### Define Constants\n\n# +\nnum_mfccs = 20\nmax_feature_length = 128\n\ntrain_data_path = \"data/audio_train/train/\"\nval_data_path = \"data/audio_train/validation/\"\n\nmodel_output_path = \"models/mfcc/\"\n# -\n\n# ### Feature Extraction\n\n# #### Let's take a look at the Librosa Python Library\n\nraw_audio, sample_rate = librosa.load(\"{}Applause/170eeda2.wav\".format(train_data_path), sr=None)\n\nraw_audio\n\nraw_audio.shape\n\nsample_rate\n\n# #### Visualize the RAW Audio\n\nplt.figure(figsize=(10, 4))\nlibrosa.display.waveplot(raw_audio, sr=sample_rate)\nplt.title('RAW Audio')\n\n# #### Extract MFCCs using Librosa\n\nmfccs = librosa.feature.mfcc(y=raw_audio, sr=sample_rate, n_mfcc=num_mfccs)\n\nmfccs\n\nmfccs.shape\n\n# #### Visualize the MFCCs\n\nplt.figure(figsize=(10, 4))\nlibrosa.display.specshow(mfccs, x_axis='time')\nplt.colorbar()\nplt.title('MFCC')\nplt.tight_layout()\n\n\n# #### Define a Method to Extact MFCCs from an Audio File\n\ndef get_mfccs(wav_file, num_mfcc=20, max_length=128):\n raw_audio, sample_rate = librosa.load(wav_file, sr=None, duration=1)\n mfccs = librosa.feature.mfcc(y=raw_audio, sr=sample_rate, n_mfcc=num_mfcc)\n \n # Truncate Each MFCC to max_length\n if (max_length > mfccs.shape[1]):\n pad_width = max_length - mfccs.shape[1]\n mfccs = np.pad(mfccs, pad_width=((0, 0), (0, pad_width)), mode='constant')\n else:\n mfccs = mfccs[:, :max_length]\n \n return mfccs\n\n\n# #### Process all Files and Extract Features\n\n# +\nmfcc_list = []\ncategory_list = []\n\nfor root, subdirs, files in os.walk(train_data_path):\n subdirs.sort()\n for subdir in subdirs:\n for file_name in os.listdir(os.path.join(root, subdir)):\n if file_name.endswith(\".wav\"):\n mfcc = get_mfccs(os.path.join(root, subdir, file_name), num_mfccs, max_feature_length)\n mfcc_list.append(mfcc)\n category_list.append(subdir)\n# -\n\nX_features = np.array(mfcc_list)\n\nfrom sklearn import preprocessing\nle = preprocessing.LabelEncoder()\ny_features = keras.utils.np_utils.to_categorical(le.fit_transform(category_list))\n\n# ### Save Feature Extraction Results to Disk\n\n# Note: We're saving the extracted features to a file in case we need them later on. This helps us not have to re-run the Feature Extraction Steps.\n\nnp.save(\"{}features.npy\".format(model_output_path), X_features)\nnp.save(\"{}labels.npy\".format(model_output_path), y_features)\nnp.save(\"{}label_encoder.npy\".format(model_output_path), le)\n\n# ### Model Training\n\n# +\nmodel = Sequential()\nmodel.add(BatchNormalization(input_shape=[X_features.shape[1], X_features.shape[2]]))\nmodel.add(LSTM(units=128, dropout=0.05, recurrent_dropout=0.35, return_sequences=True))\nmodel.add(LSTM(units=32, dropout=0.05, recurrent_dropout=0.35, return_sequences=False))\nmodel.add(Dense(len(le.classes_), activation='softmax'))\n\nmodel.compile(loss='categorical_crossentropy', optimizer='Adam', metrics=['categorical_accuracy'])\n\nmodel.fit(X_features, y_features, batch_size=16, epochs=50)\n# -\n\n# ### Now that our Model is trained, let's take a look at the Model Layers\n\nmodel.summary()\n\n# ### Save the Trained Model to Disk\n\nfrom keras.models import load_model\nmodel.save(\"{}model.h5\".format(model_output_path))\n\n# ### Let's Take a Look at How the Model is Performing\n\nmfcc = np.array([get_mfccs(\"{}Bass_drum/f78fbf28.wav\".format(val_data_path), num_mfccs, max_feature_length)])\n\nprediction = model.predict(mfcc)\nprediction\n\nle.classes_[np.argmax(prediction)]\n\n# ### Let's run Prediction on the files in our Validation DataSet\n\n# ### Load the Validation Dataset\n\ndf_validation = pd.read_csv(\"data/validation_split.csv\")\n\ndf_validation[\"predicted_label\"] = \"\"\n\nprint(df_validation.shape)\ndf_validation.head()\n\n# ### Iterate over the Validation Dataset and Run the Model Prediction Step\n\nfor index, row in df_validation.iterrows():\n val_file_path = \"{}{}/{}\".format(val_data_path, row['label'], row['fname'])\n \n mfcc = np.array([get_mfccs(val_file_path, num_mfccs, max_feature_length)])\n prediction = model.predict(mfcc)\n predicted_label = le.classes_[np.argmax(prediction)]\n\n df_validation.at[index,'predicted_label'] = predicted_label\n\ndf_validation.head()\n\n# ### Let's Review our F1 Score per Category\n\n# +\ny_val = df_validation.label\ny_val_predicted = df_validation.predicted_label\n\n# Classification Report\nfrom sklearn.metrics import classification_report\nprint(classification_report(y_val, y_val_predicted))\n# -\n\n\n"},"script_size":{"kind":"number","value":5132,"string":"5,132"}}},{"rowIdx":86,"cells":{"path":{"kind":"string","value":"/Super_Resolution- GAN.ipynb"},"content_id":{"kind":"string","value":"1034df0af1cf8d5d3d92b8d0789705b5ee2fd5e5"},"detected_licenses":{"kind":"list like","value":[],"string":"[]","isConversational":false},"license_type":{"kind":"string","value":"no_license"},"repo_name":{"kind":"string","value":"Ram-5508/Super-Resolution--GAN"},"repo_url":{"kind":"string","value":"https://github.com/Ram-5508/Super-Resolution--GAN"},"star_events_count":{"kind":"number","value":0,"string":"0"},"fork_events_count":{"kind":"number","value":0,"string":"0"},"gha_license_id":{"kind":"null"},"gha_event_created_at":{"kind":"null"},"gha_updated_at":{"kind":"null"},"gha_language":{"kind":"null"},"language":{"kind":"string","value":"Jupyter Notebook"},"is_generated":{"kind":"bool","value":false,"string":"false"},"is_vendor":{"kind":"bool","value":false,"string":"false"},"conversion_extension":{"kind":"string","value":".py"},"size":{"kind":"number","value":2701635,"string":"2,701,635"},"script":{"kind":"string","value":"# ---\n# jupyter:\n# jupytext:\n# text_representation:\n# extension: .py\n# format_name: light\n# format_version: '1.5'\n# jupytext_version: 1.15.2\n# kernelspec:\n# display_name: Python 3\n# language: python\n# name: python3\n# ---\n\n# # Task 1 : Linear Regression with Python\n\n# ## Name : Snehal Kankure\n\n# ## Predict the percentage of a student based on the no. of study hours.\n\n# Importing all libraries required for this task\nimport numpy as np\nimport pandas as pd\nimport matplotlib.pyplot as plt\n# %matplotlib inline\nfrom sklearn.model_selection import train_test_split\nfrom sklearn.linear_model import LinearRegression\nfrom sklearn import metrics\nimport math\n\n# Reading the data\nlink = \"http://bit.ly/w-data\"\ndata = pd.read_csv(link)\n\ndata.head()\n\n# ## Plotting the graph\n\n# Plotting the distribution of scores\ndata.plot(x = 'Hours', y = 'Scores',style = 'o')\nplt.title('Hours vs Percentage')\nplt.xlabel('Hours Studied')\nplt.ylabel('Percentage Score')\nplt.show()\n\n# #### The graph depicts that there is a positive correlation between the hours studied and percentage score.\n\n# ## Splitting the data using train_test_split\n\n# Preparing the data\nX = np.array(data.drop(['Scores'], 1))\nY = np.array(data['Scores'])\n\nX_train, X_test, y_train, y_test = train_test_split(X,Y, test_size = 0.2, random_state = 0)\n\n# ## Implementing Linear Regression Model\n\nlinear = LinearRegression()\n\nlinear.fit(X_train, y_train)\n\n# ## Fitting the regression line\n\n# +\n# Plotting the regression line\nline = linear.coef_*X + linear.intercept_\n\n# Plotting for the test data\nplt.scatter(X, Y)\nplt.plot(X, line)\nplt.show()\n# -\n\n# ## Prediction using test data\n\ny_pred = linear.predict(X_test)\n\ny_pred\n\n# ## Comparing the actual and predicted values\n\ndf = pd.DataFrame({'Actual' : y_test, 'Predicted' : y_pred})\n\ndf\n\n# ## Evaluating the model\n\nprint('Mean Absolute Error : ', metrics.mean_absolute_error(y_test, y_pred))\n\nprint('Mean Squared Error : ', metrics.mean_squared_error(y_test, y_pred))\n\nprint('Root Mean Squared Error : ', math.sqrt(metrics.mean_squared_error(y_test, y_pred)))\n\n# ## Predicting the value for given question\n\n# Testing with our own data\nhours = np.array([9.25])\nhours = hours.reshape((1,1))\nown_pred = linear.predict(hours)\nprint(\"No of hours = {}\". format(hours))\nprint(\"Predicted Score = {}\". format(own_pred[0]))\n\n\ntlib.pyplot as plt\nimport pandas as pd\n\n# We load the dataset and sort out the attributes that are needed for the formulation of the model.\n\n# Load Dataset\nurl = \"https://archive.ics.uci.edu/ml/machine-learning-databases/breast-cancer-wisconsin/breast-cancer-wisconsin.data\"\nnames = ['id', 'clump_thickness', 'uniform_cell_size', 'uniform_cell_shape',\n 'marginal_adhesion', 'single_epithelial_size', 'bare_nuclei',\n 'bland_chromatin', 'normal_nucleoli', 'mitoses', 'class']\ndf = pd.read_csv(url, names=names)\n\n# Now, we clean the obtained data by replacing invalid values and dropping unecessary columns.\n\n# +\n# Preprocess the data\ndf.replace('?',-99999, inplace=True)\nprint(df.axes)\n\ndf.drop(['id'], 1, inplace=True)\n\n# +\n# Let explore the dataset and do a few visualizations\nprint(df.loc[10])\n\n# Print the shape of the dataset\nprint(df.shape)\n# -\n\n# Getting to know about the statistics of each attribute.\n\n# Describe the dataset\nprint(df.describe())\n\n# Plot histograms for each variable\ndf.hist(figsize = (10, 10))\nplt.show()\n\n# Create scatter plot matrix\nscatter_matrix(df, figsize = (18,18))\nplt.show()\n\n# ### The above result shows the relationship between attributes and that we can go ahead with the modelling. ###\n\n# Now lets split the dataset for testing and training.\n\n# +\n# Create X and Y datasets for training\nX = np.array(df.drop(['class'], 1))\ny = np.array(df['class'])\n\nX_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)\n# -\n\n# Testing Options\nseed = 8\nscoring = 'accuracy'\n\n# Comparing the KNN and SVC models on the dataset.\n\n# +\n# Define models to train\nmodels = []\nmodels.append(('KNN', KNeighborsClassifier(n_neighbors = 5)))\nmodels.append(('SVM', SVC()))\n\n# evaluate each model in turn\nresults = []\nnames = []\n\nfor name, model in models:\n kfold = model_selection.KFold(n_splits=10, random_state = seed)\n cv_results = model_selection.cross_val_score(model, X_train, y_train, cv=kfold, scoring=scoring)\n results.append(cv_results)\n names.append(name)\n msg = \"%s: %f (%f)\" % (name, cv_results.mean(), cv_results.std())\n print(msg)\n\n# +\n# Make predictions on validation dataset\n\nfor name, model in models:\n model.fit(X_train, y_train)\n predictions = model.predict(X_test)\n print(name)\n print(accuracy_score(y_test, predictions))\n print(classification_report(y_test, predictions))\n \n# Accuracy - ratio of correctly predicted observation to the total observations. \n# Precision - (false positives) ratio of correctly predicted positive observations to the total predicted positive observations\n# Recall (Sensitivity) - (false negatives) ratio of correctly predicted positive observations to the all observations in actual class - yes.\n# F1 score - F1 Score is the weighted average of Precision and Recall. Therefore, this score takes both false positives and false\n# -\n\n# ### The above result shows the SVC to be a more accurate model for this case ###\n\n# Going ahead with the SVC model to predict the unknown.\n\n# +\nclf = SVC()\n\nclf.fit(X_train, y_train)\naccuracy = clf.score(X_test, y_test)\nprint(accuracy)\n\nexample_measures = np.array([[4,2,1,1,1,2,3,2,1]])\nexample_measures = example_measures.reshape(len(example_measures), -1)\nprediction = clf.predict(example_measures)\nprint(prediction)\n# -\n\n\ntil as GPU\ngpu = GPU.getGPUs()[0]\nprocess = psutil.Process(os.getpid())\nprint(f\"Gen RAM: Free {humanize.naturalsize(psutil.virtual_memory().available)} | Proc size {humanize.naturalsize(process.memory_info().rss)}\")\nprint(f\"GPU RAM: Free {gpu.memoryFree:.0f}MB | Used {gpu.memoryUsed:.0f}MB | Util {gpu.memoryUtil*100:.0f}% | Total {gpu.memoryTotal:.0f}MB\")\n\n# + [markdown] id=\"HMubMpKy15ac\" colab_type=\"text\"\n# # **Main Code**\n\n# + [markdown] id=\"pIuewxbgsM4d\" colab_type=\"text\"\n# ## Data Loading\n\n# + id=\"C4DoUU8GYJes\" colab_type=\"code\" colab={}\nimport cv2\nimport numpy as np\nimport matplotlib.pyplot as plt\n# %matplotlib inline\nimport os\n\n# + id=\"aS8Xf5iwpeXt\" colab_type=\"code\" outputId=\"390232fa-c195-4319-f9fa-3efd67779089\" colab={\"base_uri\": \"https://localhost:8080/\", \"height\": 50}\ntrain_img=[]\ntrain_hr_path = '/content/rephrase-pubfig831/degraded/train'\nfor subdir, dirs, _ in os.walk(train_hr_path):\n for file in dirs:\n path = os.path.join(subdir,file)\n for i in os.listdir(path):\n img = cv2.imread(os.path.join(path,i))\n img = cv2.resize(img , (250,250))\n train_img.append(img)\ntrain_img = np.array(train_img).astype('uint8')\n\nreal_img=[]\ntrain_lr_path = '/content/rephrase-pubfig831/correct/train'\nfor subdir, dirs, _ in os.walk(train_lr_path):\n for file in dirs:\n path = os.path.join(subdir,file)\n for i in os.listdir(path):\n img = cv2.imread(os.path.join(path,i))\n img = cv2.resize(img , (250,250))\n real_img.append(img)\nreal_img = np.array(real_img).astype('uint8')\n\nprint(train_img.shape) \nprint(real_img.shape)\n\n# + id=\"imAwlarzIEdC\" colab_type=\"code\" outputId=\"e5967d5c-2331-4a59-fafb-d17858862bba\" colab={\"base_uri\": \"https://localhost:8080/\", \"height\": 285}\nplt.imshow(train_img[0][:,:,::-1])\n\n# + id=\"hd6AFx0vCBVD\" colab_type=\"code\" colab={}\nbatch_size = 1\nbatch_count = (real_img.shape[0]//batch_size)\n\n# + [markdown] id=\"bSV-9eYyfbX2\" colab_type=\"text\"\n# ## Structure\n\n# + [markdown] id=\"jqLOT8BUsAaW\" colab_type=\"text\"\n# ### **Constants and Hyperparemeters**\n\n# + id=\"S8NNBxqO4qPH\" colab_type=\"code\" outputId=\"599c94e4-a745-47b7-a0c5-546c514d7f9a\" colab={\"base_uri\": \"https://localhost:8080/\", \"height\": 407}\nimport tensorflow as tf\nlearning_rate = 0.0001\n\n# + id=\"eCk3LSlUACtO\" colab_type=\"code\" outputId=\"bf80e582-b9ab-4e93-f104-4e8218870c1a\" colab={\"base_uri\": \"https://localhost:8080/\", \"height\": 33}\n\ntf.__version__\n\n\n# + [markdown] id=\"xQr7M263s-CE\" colab_type=\"text\"\n# ### Generator Model\n\n# + id=\"vLjLc0INPJY6\" colab_type=\"code\" colab={}\ndef generator():\n \n inp = tf.keras.layers.Input(shape=(250,250,3))\n l1=(tf.keras.layers.Conv2D(64,(3,3),padding='same',activation='relu'))(inp)\n l1=(tf.keras.layers.BatchNormalization(momentum=0.8))(l1)\n nn = l1\n for i in range(0,6):\n res=(tf.keras.layers.Conv2D(64,(3,3),padding='same',activation='relu'))(nn)\n #res=(tf.keras.layers.BatchNormalization(momentum=0.5))(res)\n nn = res\n residual_out = tf.keras.layers.add([l1,res])\n l2=(tf.keras.layers.Conv2D(64,(3,3),padding='same',activation='relu'))(residual_out)\n l3=(tf.keras.layers.Conv2D(3,(3,3),padding='same',activation='tanh'))(l2)\n final = (tf.keras.layers.BatchNormalization())(l3)\n\n model = tf.keras.models.Model(inputs = inp , outputs = final)\n model.summary()\n return model\n \n\n\n# + id=\"koLS0F47Ax58\" colab_type=\"code\" outputId=\"39d19cef-78f9-4e51-a088-826ed2ba4733\" colab={\"base_uri\": \"https://localhost:8080/\", \"height\": 586}\nmodel_generator = generator()\n\n# + id=\"2dgf05ciaY42\" colab_type=\"code\" outputId=\"a0dddd6f-8fb0-4d45-9164-63ffd1c0afee\" colab={\"base_uri\": \"https://localhost:8080/\", \"height\": 285}\nimg = np.reshape(train_img[0],(1,250,250,3))\ntrial = tf.image.convert_image_dtype(img,tf.float32)\nnew = tf.image.convert_image_dtype(real_img[0],tf.float32)\npred = model_generator.predict(trial)\npred = tf.image.convert_image_dtype(pred,tf.uint8)\npred = pred[:,:,:,::-1] \n\nplt.imshow(tf.reshape(pred[0],(250,250,3)))\nprint(pred.shape)\n\n\n# + [markdown] id=\"_u7Eq3yltYld\" colab_type=\"text\"\n#\n\n# + id=\"qQ6tsJqgi-Gd\" colab_type=\"code\" colab={}\ndef discriminator():\n model = tf.keras.models.Sequential()\n model.add(tf.keras.layers.Conv2D(64,(3,3),input_shape=(250,250,3)))\n model.add(tf.keras.layers.LeakyReLU())\n model.add(tf.keras.layers.Conv2D(64,(3,3),input_shape=(250,250,3)))\n model.add(tf.keras.layers.LeakyReLU())\n model.add(tf.keras.layers.Flatten())\n model.add(tf.keras.layers.Dense(32,activation='relu'))\n model.add(tf.keras.layers.Dense(1,activation='sigmoid'))\n return model\n\n\n# + id=\"I_0WEqG7GNna\" colab_type=\"code\" colab={}\nmodel_discriminator = discriminator()\n\n\n# + [markdown] colab_type=\"text\" id=\"bVjtttv0fKhp\"\n#\n# ### Loss Functions\n\n# + id=\"uD0xLY_FfRRO\" colab_type=\"code\" colab={}\ndef loss_disc(real_output,fake_output):\n real_output = tf.sigmoid(real_output)\n fake_output = tf.sigmoid(fake_output)\n real_loss = tf.losses.binary_crossentropy(tf.ones_like(batch_size),real_output)\n fake_loss = tf.losses.binary_crossentropy(tf.zeros_like(batch_size),fake_output)\n return real_loss + fake_loss\n\ndef loss_gen(fake_output):\n fake_output = tf.sigmoid(fake_output)\n fake_loss = tf.losses.binary_crossentropy(tf.ones_like(batch_size),fake_output)\n return fake_loss\n\n\n# + id=\"eZptm4sy_8FP\" colab_type=\"code\" outputId=\"b0320495-db6b-4668-cf9b-0434b8e726bb\" colab={\"base_uri\": \"https://localhost:8080/\", \"height\": 50}\nresnet = tf.keras.applications.resnet50.ResNet50(include_top=False , weights = 'imagenet',input_shape=(250,250,3))\nresnet.trainable = False\nmodel_res = tf.keras.models.Model(inputs = resnet.input ,outputs= resnet.output)\nmodel_res.trainable = False\ndef resnet_loss(real,fake):\n hr = model_res.predict(real)\n lr = model_res.predict(fake)\n loss = tf.keras.losses.mean_squared_error(hr,lr)\n return np.mean(loss)\n\n\n# + id=\"YERIQsYriYXA\" colab_type=\"code\" colab={}\ndef color_loss(real,fake):\n loss = tf.keras.losses.mean_squared_error(real,fake)\n return (loss)\n\n\n# + [markdown] colab_type=\"text\" id=\"OHWHhltZfP2r\"\n# ### Optimizer\n\n# + id=\"PhL1Myvmopcg\" colab_type=\"code\" colab={}\noptimizer_gen = tf.keras.optimizers.Adam(learning_rate)\noptimizer_disc = tf.keras.optimizers.Adam(learning_rate)\n\n# + [markdown] id=\"db_eANXWf52U\" colab_type=\"text\"\n# ## Preprocessing\n\n# + [markdown] id=\"No1MjnCQsoP9\" colab_type=\"text\"\n# ### Setting device to use for tensor operations\n\n# + id=\"DCZ5YQ4uJbP6\" colab_type=\"code\" colab={}\n\n\n# + [markdown] id=\"1q_IX5GGs0hh\" colab_type=\"text\"\n# ### Initializing weights (if required)\n\n# + id=\"huQiEB4sLP4c\" colab_type=\"code\" outputId=\"a95fa163-5311-4800-9d8e-61821ce1a9bc\" colab={\"base_uri\": \"https://localhost:8080/\", \"height\": 33}\ntrained_model = tf.keras.models.load_model('/content/new.h5')\n\n\n# + [markdown] id=\"u7msb0gPuC2A\" colab_type=\"text\"\n# ## Training\n\n# + id=\"K6Ccj64AtlK8\" colab_type=\"code\" colab={}\ndef start(epochs):\n for e in range(epochs):\n train_model(e)\n if e%5 == 0:\n model_generator.save('/content/train_model.h5')\n\n\n# + id=\"zYFdUIscKJOg\" colab_type=\"code\" colab={}\ndef train_model(e):\n rand = np.random.randint(0,train_img.shape[0],size = batch_size)\n low=[]\n high=[]\n for num in rand:\n low.append(train_img[num])\n high.append(real_img[num])\n low = np.array(low).astype('float32')\n high = np.array(high).astype('float32')\n\n noise_image = low/255\n\n with tf.GradientTape() as gen_tape , tf.GradientTape() as disc_tape:\n generated_image = model_generator(noise_image)\n\n r_image= high/255\n real_output = model_discriminator(r_image)\n fake_output = model_discriminator(generated_image)\n\n real_loss = loss_disc(real_output,fake_output)\n fake_loss_out = loss_gen(fake_output)\n loss_mse = color_loss(r_image,generated_image)\n content_loss = resnet_loss(r_image , generated_image)\n fake_loss = content_loss + fake_loss_out+loss_mse \n\n gradient_gen = gen_tape.gradient(fake_loss , model_generator.trainable_variables)\n gradient_disc = disc_tape.gradient(real_loss , model_discriminator.trainable_variables)\n\n optimizer_disc.apply_gradients(zip(gradient_disc,model_discriminator.trainable_variables))\n optimizer_gen.apply_gradients(zip(gradient_gen,model_generator.trainable_variables))\n\n print('Epoch : {} , loss: {}'.format(e,np.mean(fake_loss)))\n\n\n# + id=\"9Mu_m83NLQNd\" colab_type=\"code\" colab={}\nstart(batch_count)\n\n# + [markdown] id=\"EloW4JAcyYDJ\" colab_type=\"text\"\n# ## Evaluation\n\n# + id=\"SIAidhJQY0s9\" colab_type=\"code\" outputId=\"6f2b7adc-ae4f-482f-8411-723aecb7abc2\" colab={\"base_uri\": \"https://localhost:8080/\", \"height\": 285}\ntrial = np.reshape(train_img[1],(1,250,250,3))\ntrial = trial/255\ntrial = trial.astype('float32')\n\nnew = tf.image.convert_image_dtype(real_img[8534],tf.float32)\npred = trained_model.predict(trial)\npred = tf.image.convert_image_dtype(pred,tf.uint8)\n\npred = pred[:,:,:,::-1]\n\nplt.imshow(tf.reshape(pred,(250,250,3)))\nprint(pred.shape)\n\n# + id=\"9h1FFAS45TTm\" colab_type=\"code\" outputId=\"b16b462e-5ee5-48db-9819-270b3e4b8e95\" colab={\"base_uri\": \"https://localhost:8080/\", \"height\": 286}\nr = (train_img[1])\nplt.imshow(r[:,:,::-1])\n\n# + id=\"m2ctYf4fcCsl\" colab_type=\"code\" outputId=\"1c0672a5-5063-4cc8-c1a5-ee7dd4170504\" colab={\"base_uri\": \"https://localhost:8080/\", \"height\": 286}\nr = (real_img[1])\nplt.imshow(r[:,:,::-1])\n\n\n# + id=\"FNnCAsPZgyqn\" colab_type=\"code\" colab={}\ndef fix(image):\n \"\"\"\n This function should take a degraded image in BGR format as a 250x250x3\n numpy array with dtype np.uint8, and return its fixed version in the same format.\n\n Make sure you don't return floating point values, or RGB instead of BGR, else the\n image will look completely wrong when displayed.\n \"\"\"\n image = np.reshape(image,(1,250,250,3))\n image = image/255\n image = tf.image.convert_image_dtype(image,tf.float32)\n img = trained_model(image)\n img = tf.image.convert_image_dtype(img,tf.uint8)\n img = np.reshape(img,(250,250,3))\n return img\n\n\n# + [markdown] id=\"hZk4RFZhnpab\" colab_type=\"text\"\n# # Results\n# Run this block after done to look at some of the results of the fix function. Do not change this block in any way. Instead write the fix function in a way that makes sure that this block works.\n\n# + id=\"akZdSIK8odKM\" colab_type=\"code\" outputId=\"8eab27be-5758-4f1f-ec53-7713acfaa0d8\" colab={\"base_uri\": \"https://localhost:8080/\", \"height\": 1000}\n# %matplotlib inline\n\nimport os\nimport random\nfrom glob import glob\n\nimport cv2\nimport matplotlib.pyplot as plt\nimport numpy as np\n\nNUM_DISPLAY = 5\n\nfiles = glob('/content/rephrase-pubfig831/correct/test/*/*')\ngrid = []\n\nfor path in random.sample(files, NUM_DISPLAY):\n correct = cv2.imread(path)\n split = path.split('/')\n degraded = cv2.imread('/'.join([*split[:3], 'degraded', *split[4:]]))\n #degraded = np.reshape(degraded , (1,250,250,3))\n fixed = fix(degraded)\n grid.append(np.column_stack([degraded, fixed, correct]))\n\nimage = np.row_stack(grid)\ndpi = float(plt.rcParams['figure.dpi'])\nfigsize = image.shape[1] / dpi, image.shape[0] / dpi\nax = plt.figure(figsize=figsize).add_axes([0, 0, 1, 1])\nax.axis('off')\nax.imshow(image[..., ::-1])\nplt.show()\n\n# + id=\"0E4DQkecc63V\" colab_type=\"code\" colab={}\n\n"},"script_size":{"kind":"number","value":16725,"string":"16,725"}}},{"rowIdx":87,"cells":{"path":{"kind":"string","value":"/Python Dev/python_assignment.ipynb"},"content_id":{"kind":"string","value":"099819126d7c47f88e1ea066e6881b103249bca0"},"detected_licenses":{"kind":"list like","value":["MIT"],"string":"[\n \"MIT\"\n]","isConversational":false},"license_type":{"kind":"string","value":"permissive"},"repo_name":{"kind":"string","value":"Buhle/Assessments"},"repo_url":{"kind":"string","value":"https://github.com/Buhle/Assessments"},"star_events_count":{"kind":"number","value":0,"string":"0"},"fork_events_count":{"kind":"number","value":0,"string":"0"},"gha_license_id":{"kind":"string","value":"MIT"},"gha_event_created_at":{"kind":"timestamp","value":"2020-04-01T14:02:52","string":"2020-04-01T14:02:52"},"gha_updated_at":{"kind":"timestamp","value":"2019-04-04T06:58:24","string":"2019-04-04T06:58:24"},"gha_language":{"kind":"null"},"language":{"kind":"string","value":"Jupyter Notebook"},"is_generated":{"kind":"bool","value":false,"string":"false"},"is_vendor":{"kind":"bool","value":false,"string":"false"},"conversion_extension":{"kind":"string","value":".py"},"size":{"kind":"number","value":9193,"string":"9,193"},"script":{"kind":"string","value":"# ---\n# jupyter:\n# jupytext:\n# text_representation:\n# extension: .py\n# format_name: light\n# format_version: '1.5'\n# jupytext_version: 1.15.2\n# kernelspec:\n# display_name: Python 3\n# language: python\n# name: python3\n# ---\n\n# +\nimport datetime\nimport json\nimport numpy as np\nimport pandas as pd\nfrom pandas import Series, DataFrame\nimport pprint\nimport time\nimport re\nimport requests\n\nimport sklearn\nfrom sklearn.linear_model import LinearRegression\n\nimport matplotlib.pyplot as plt\n# %matplotlib inline\n\nimport seaborn as sns\nsns.set_style('whitegrid')\n# -\n\nurl = \"https://api.syosetu.com/novelapi/api/\"\n\n# +\n# 収集データの決定\ndata_info_of = 't-s-bg-g-k-gf-gl-nt-ga-l-ir-izk-its-iti-gp-dp-wp-mp-qp-yp-f-imp-r-a-ah-sa-ka'\n \npayload_daily = {'out': 'json', 'order': 'dailypoint', 'lim': 100, 'biggenre': '2', \n 'of': data_info_of}\n\n# -\n\nd = requests.get(url, params=payload_daily)\njson_data = d.json()\n\nprint(len(json_data))\njson_data\n\n# +\ndatas = []\ndatas.extend(json_data[1:])\n\ncolumns = []\nfor c in datas[0]:\n columns.append(c)\n# -\n\nbf_df = pd.DataFrame(datas, columns=columns)\n\ndf = bf_df.copy()\n\ntitle_length = []\nkeyword_length = []\nstory_length = []\n\nfor x, y, z in zip(df.title, df.keyword, df.story):\n try:\n title_length.append(len(x))\n keyword_length.append(len(y))\n story_length.append(len(z))\n except TypeError:\n continue\n\ndf.title = title_length\ndf.keyword = keyword_length\ndf.story = story_length\n\ndf\n\nnow_date = datetime.datetime.now()\n\nnow_date\n\n\ndef difference_type_search(self):\n date_pattern = r'....-..-.. ..:..:..'\n dt = []\n st = []\n \n for index, d in enumerate(self):\n if type(d) == str:\n if re.search(date_pattern, d) != None:\n for i, d in enumerate(df):\n if i == index:\n dt.append(d)\n else:\n for i, d in enumerate(df):\n if i == index:\n st.append(d)\n return dt, st\n\n\ndef df_type_change(self):\n dts_d = difference_type_search(df.iloc[0])[0]\n dts_s = difference_type_search(df.iloc[0])[1]\n \n for d in dts_d:\n difference_date = []\n for t in df[d]:\n df_date = datetime.datetime.strptime(t, '%Y-%m-%d %H:%M:%S')\n day_sa = now_date - df_date\n difference_date.append(day_sa.days)\n df[d] = difference_date\n \n for d in dts_s:\n length = []\n for i in df[d]:\n length.append(len(i))\n df[d] = length\n\n\ndifference_type_search(df.iloc[0])\n\ndf_type_change(df)\n\ndf\n\n# +\n# .max() 最大値\n# .min() 最小値\n# .mode() 最頻値\n# .mean() 平均値\n# .median() 中央値\n# .std() 標準偏差\n# .count() 件数\n# .corr() 相関係数（列間のデータの相関関係を数値化、主にテーブル全体に対して使う。）\n# .unique() カテゴリカルデータの項目を表示\n# .value_counts() 項目別数量\n\n# +\n# numpy.sqrt(x)\t配列xの平方根を求めます。\n# numpy.cbrt(x)\t配列xの立方根（三乗根）を求めます。\n# numpy.square(x)\t配列xの二乗を求めます。\n# -\n\nX = df.daily_point\nY = df.yearly_point\n\nX = np.array([[value, 1] for value in X])\n\nmodel = LinearRegression()\nmodel.fit(X, Y)\nprint('切片:', model.intercept_)\nprint('傾き:', model.coef_)\n\na,b = np.linalg.lstsq(X, Y)[0]\n\n# +\nplt.plot(df.yearly_point, df.kaiwaritu, 'o')\n\nx = df.yearly_point\nplt.plot(x, a*x+b, 'r')\n# -\n\nlreg = LinearRegression()\n\nX_multi = df.drop('daily_point', 1)\n\nX_multi.shape\n\nY_target = df.daily_point\n\nlreg.fit(X_multi, Y_target)\n\nlreg.intercept_\n\nlen(lreg.coef_)\n\ncoeff_df = DataFrame(df.columns)\n\ncoeff_df.columns = ['Featers']\n\ncoeff_df['Coefficient Estimate'] = pd.Series(lreg.coef_)\n\ncoeff_df\n\nX_train, X_test,Y_train, Y_test = sklearn.model_selection.train_test_split(X_multi,df.daily_point)\n\nprint(X_train.shape, X_test.shape, Y_train.shape, Y_test.shape) \n\nlreg = LinearRegression()\nlreg.fit(X_train,Y_train)\n\npred_train = lreg.predict(X_train)\npred_test = lreg.predict(X_test)\n\n# +\nprint('X_trainを使ったモデルの平均二乗誤差＝{:0.2f}'.format(np.mean((Y_train - pred_train) ** 2)))\n \nprint('X_testを使ったモデルの平均二乗誤差＝{:0.2f}'.format(np.mean((Y_test - pred_test) ** 2)))\n\n# +\n# 学習用のデータの残差プロットです。\ntrain = plt.scatter(pred_train,(pred_train-Y_train),c='b',alpha=0.5)\n\n# テスト用のデータの残差プロットです。\ntest = plt.scatter(pred_test,(pred_test-Y_test),c='r',alpha=0.5)\n\n# y=0の水平な線を描いておきます。\nplt.hlines(y=0,xmin=-10,xmax=50)\n\nplt.legend((train,test),('Training','Test'),loc='lower left')\nplt.title('Residual Plots')\n# -\n\n\n"},"script_size":{"kind":"number","value":4353,"string":"4,353"}}},{"rowIdx":88,"cells":{"path":{"kind":"string","value":"/univariate-linear-regression.ipynb"},"content_id":{"kind":"string","value":"405dd9c2e532caae188df4907698a4cea28c6f5c"},"detected_licenses":{"kind":"list like","value":[],"string":"[]","isConversational":false},"license_type":{"kind":"string","value":"no_license"},"repo_name":{"kind":"string","value":"cricketjanoon/linear-regression-pytorch"},"repo_url":{"kind":"string","value":"https://github.com/cricketjanoon/linear-regression-pytorch"},"star_events_count":{"kind":"number","value":0,"string":"0"},"fork_events_count":{"kind":"number","value":0,"string":"0"},"gha_license_id":{"kind":"null"},"gha_event_created_at":{"kind":"null"},"gha_updated_at":{"kind":"null"},"gha_language":{"kind":"null"},"language":{"kind":"string","value":"Jupyter Notebook"},"is_generated":{"kind":"bool","value":false,"string":"false"},"is_vendor":{"kind":"bool","value":false,"string":"false"},"conversion_extension":{"kind":"string","value":".py"},"size":{"kind":"number","value":32218,"string":"32,218"},"script":{"kind":"string","value":"# ---\n# jupyter:\n# jupytext:\n# text_representation:\n# extension: .py\n# format_name: light\n# format_version: '1.5'\n# jupytext_version: 1.15.2\n# kernelspec:\n# display_name: pytorch-gpu\n# language: python\n# name: pytorch-gpu\n# ---\n\nimport torch\nimport pandas as pd\nfrom matplotlib import pyplot as plt\n\n# +\n#reading data\n\ndf = pd.read_csv('salary_data.csv')\n\nx = df['YearsExperience'].values\ny = df['Salary'].values\n\nx = torch.from_numpy(x).float()\ny = torch.from_numpy(y).float()\n\nx = x.view(30, -1)\ny = y.view(30, -1)\n\n# +\n# initializing weight and bias\n\nw = torch.randn(1, 1, requires_grad=True)\nb = torch.randn(1, requires_grad=True)\n\nprint(w.shape)\nprint(b.shape)\n\n\n# +\n# linear regression model\n\ndef linreg_model(x):\n return x @ w + b\n\ny_pred = linreg_model(x)\n\n\n# +\n# mean square loss\n\ndef calculate_loss(y_true, y_pred):\n diff = y_true - y_pred\n return torch.sum(diff * diff) / diff.numel()\n\nloss = calculate_loss(y, y_pred)\nprint(loss)\n\n# +\n# hyperparamters\n\nlr = 0.002\nepochs = 100\n\n# +\n#training loop\n\nloss_hist = []\nfor epoch in range(epochs):\n y_pred = linreg_model(x)\n loss = calculate_loss(y, y_pred)\n loss.backward()\n loss_hist.append(loss.item())\n with torch.no_grad():\n w -= w.grad * lr\n b -= b.grad * lr\n w.grad.zero_()\n b.grad.zero_()\n# -\n\npreds = linreg_model(x)\nloss = calculate_loss(preds, y)\nprint(loss)\n\nplt.plot(range(epochs), loss_hist)\nplt.xlabel(\"# of epochs\")\nplt.ylabel(\"training error\")\nplt.title(\"Epochs vs Error\")\n\nplt.scatter(x, y)\nplt.plot(x, y_pred.detach(), 'r')\nplt.xlabel('Experience')\nplt.ylabel('Salary')\n"},"script_size":{"kind":"number","value":1640,"string":"1,640"}}},{"rowIdx":89,"cells":{"path":{"kind":"string","value":"/notebooks/aggregations-joins-sparksql.ipynb"},"content_id":{"kind":"string","value":"008166feaa2d81073f8b94a951cdfd3a3d14756a"},"detected_licenses":{"kind":"list like","value":[],"string":"[]","isConversational":false},"license_type":{"kind":"string","value":"no_license"},"repo_name":{"kind":"string","value":"parijatbanik/spark-examples"},"repo_url":{"kind":"string","value":"https://github.com/parijatbanik/spark-examples"},"star_events_count":{"kind":"number","value":0,"string":"0"},"fork_events_count":{"kind":"number","value":0,"string":"0"},"gha_license_id":{"kind":"null"},"gha_event_created_at":{"kind":"null"},"gha_updated_at":{"kind":"null"},"gha_language":{"kind":"null"},"language":{"kind":"string","value":"Jupyter Notebook"},"is_generated":{"kind":"bool","value":false,"string":"false"},"is_vendor":{"kind":"bool","value":false,"string":"false"},"conversion_extension":{"kind":"string","value":".py"},"size":{"kind":"number","value":48219,"string":"48,219"},"script":{"kind":"string","value":"# ---\n# jupyter:\n# jupytext:\n# text_representation:\n# extension: .py\n# format_name: light\n# format_version: '1.5'\n# jupytext_version: 1.15.2\n# kernelspec:\n# display_name: Python 3\n# language: python\n# name: python3\n# ---\n\n# ## Examples for Aggregation functions, joins and SQL \n\n# +\nfrom pyspark.sql import SparkSession\nimport pandas as pd\n\nspark = SparkSession.builder.appName(\"SimpleApp2\").getOrCreate()\nspark.conf.set(\"spark.sql.shuffle.partitions\", \"5\")\nnetflix = spark.read.csv(\"../data/netflix_titles.csv\",header='true')\nnetflix.limit(5).toPandas().head()\n\n# +\navocadoprice = spark.read.csv(\"../data/avocado.csv\",header='true')\n\navocadoprice.cache()\navocadoprice.createOrReplaceTempView(\"avocadopriceTable\")\n\navocadoprice.limit(5).toPandas().head()\n# -\n\nfrom pyspark.sql.functions import count\navocadoprice.select(count(\"AveragePrice\")).show()\n\nfrom pyspark.sql.functions import countDistinct\navocadoprice.select(countDistinct(\"AveragePrice\")).show()\n\nfrom pyspark.sql.functions import min,max\navocadoprice.select(min(\"AveragePrice\"),max(\"AveragePrice\")).show()\n\n# +\nfrom pyspark.sql.functions import var_pop, stddev_pop\nfrom pyspark.sql.functions import var_samp, stddev_samp\n\navocadoprice.select(var_pop(\"AveragePrice\"), var_samp(\"AveragePrice\"),\n stddev_pop(\"AveragePrice\"), stddev_samp(\"AveragePrice\")).show()\n\n# +\nfrom pyspark.sql.functions import skewness, kurtosis\n\navocadoprice.select(skewness(\"AveragePrice\"), kurtosis(\"AveragePrice\")).show()\n# -\n\n# ## Grouping\n\navocadoprice.groupBy(\"year\",\"region\").count().show()\n\n# +\nfrom pyspark.sql.window import Window\nfrom pyspark.sql.functions import desc\n\nwindowSpec = Window\\\n.partitionBy(\"_c0\", \"Date\")\\\n.orderBy(desc(\"Total Volume\"))\\\n.rowsBetween(Window.unboundedPreceding, Window.currentRow)\n# -\n\nfrom pyspark.sql.functions import max\nfrom pyspark.sql.functions import col\nmaxPurchaseQuantity = max(col(\"Quantity\")).over(windowSpec)\n\nmaxPurchaseQuantity\n\npivoted = avocadoprice.groupBy(\"region\").pivot(\"type\").sum()\n\npivoted.limit(6).toPandas().head()\n\n\n# ## Joins\n\nhappy2018 = spark.read.csv(\"../data/happiness/2018.csv\",header='true')\nhappy2018.limit(5).toPandas().head()\n\nhappy2019 = spark.read.csv(\"../data/happiness/2019.csv\",header='true')\nhappy2019.limit(5).toPandas().head()\n\n# +\n\nhappy2018.cache()\nhappy2018.createOrReplaceTempView(\"happy2018Table\")\nhappy2019.cache()\nhappy2019.createOrReplaceTempView(\"happy2019Table\")\n# -\n\nspark.sql(\"select `Country or region` as Country, `Social support` as social from happy2018Table limit 5\").show()\n\njoinExpression = happy2018[\"Country or region\"] == happy2019['Country or region']\njoinExpression\n\n# +\nperson = spark.createDataFrame([\n (0, \"Bill Chambers\", 0, [100]),\n (1, \"Matei Zaharia\", 1, [500, 250, 100]),\n (2, \"Michael Armbrust\", 1, [250, 100])])\\\n .toDF(\"id\", \"name\", \"graduate_program\", \"spark_status\")\n\ngraduateProgram = spark.createDataFrame([\n (0, \"Masters\", \"School of Information\", \"UC Berkeley\"),\n (2, \"Masters\", \"EECS\", \"UC Berkeley\"),\n (1, \"Ph.D.\", \"EECS\", \"UC Berkeley\")])\\\n .toDF(\"id\", \"degree\", \"department\", \"school\")\n\nsparkStatus = spark.createDataFrame([\n (500, \"Vice President\"),\n (250, \"PMC Member\"),\n (100, \"Contributor\")])\\\n .toDF(\"id\", \"status\")\n# -\n\nperson.createOrReplaceTempView(\"person\")\ngraduateProgram.createOrReplaceTempView(\"graduateProgram\")\nsparkStatus.createOrReplaceTempView(\"sparkStatus\")\n\njoinExpression = person[\"graduate_program\"] == graduateProgram['id']\n\nperson.join(graduateProgram, joinExpression).show()\n\njoinType = \"inner\"\nperson.join(graduateProgram, joinExpression, joinType).show()\n\njoinType = \"outer\"\nperson.join(graduateProgram, joinExpression, joinType).show()\n\njoinType = \"left_outer\"\ngraduateProgram.join(person, joinExpression, joinType).show()\n\njoinType = \"right_outer\"\nperson.join(graduateProgram, joinExpression, joinType).show()\n\njoinType = \"cross\"\ngraduateProgram.join(person, joinExpression, joinType).show()\n\n# ## Spark SQL\n\navocadoprice.limit(5).toPandas().head()\n\nspark.sql(\"\"\"SELECT Date, sum(AveragePrice) FROM avocadopriceTable GROUP BY Date \"\"\").show()\n\n\n\n"},"script_size":{"kind":"number","value":4123,"string":"4,123"}}},{"rowIdx":90,"cells":{"path":{"kind":"string","value":"/Utils/train_interactive.ipynb"},"content_id":{"kind":"string","value":"83189212600210b8d295a8f4af37cdaf43ea37ec"},"detected_licenses":{"kind":"list like","value":[],"string":"[]","isConversational":false},"license_type":{"kind":"string","value":"no_license"},"repo_name":{"kind":"string","value":"carlmoore256/VR-ML-Drumkit"},"repo_url":{"kind":"string","value":"https://github.com/carlmoore256/VR-ML-Drumkit"},"star_events_count":{"kind":"number","value":3,"string":"3"},"fork_events_count":{"kind":"number","value":0,"string":"0"},"gha_license_id":{"kind":"null"},"gha_event_created_at":{"kind":"null"},"gha_updated_at":{"kind":"null"},"gha_language":{"kind":"null"},"language":{"kind":"string","value":"Jupyter Notebook"},"is_generated":{"kind":"bool","value":false,"string":"false"},"is_vendor":{"kind":"bool","value":false,"string":"false"},"conversion_extension":{"kind":"string","value":".py"},"size":{"kind":"number","value":19686,"string":"19,686"},"script":{"kind":"string","value":"# ---\n# jupyter:\n# jupytext:\n# text_representation:\n# extension: .py\n# format_name: light\n# format_version: '1.5'\n# jupytext_version: 1.15.2\n# kernelspec:\n# display_name: 'Python 3.7.7 64-bit (''venv'': venv)'\n# name: python37764bitvenvvenvab0f665d5e6242889e1be50fddda4d67\n# ---\n\n# # Query examples\n\n# ## Example 1\n#\n# Parse the authors name of the 14th paper in the paper list queried with \"particles\", and the following 10.\n\nimport pandas as pd\nfrom pprint import pprint\nfrom scrapxiv.shelf import Shelf\n\n# Intialise a shelf with a query for deep learning papers, starting from the 14th paper in the output query, and getting the first 10 results:\n\nshelf = Shelf()\nshelf.query(keywords=\"deep learning\", start_index=14, max_results=10)\n\n# Getting the basic information of the papers in the shelf:\n\nshelf.get_papers_ids()\n\nfrom pprint import pprint\npprint(shelf.get_papers_info())\n\n# Download all the papers in the shelf in a local folder:\n\nshelf.clean_download_folder()\nshelf.download_papers()\n\npd.set_option('display.max_rows', 100)\nshelf.get_authors_dataframe(get_emails=True)\n\n# ## Example 2\n# Query authors data from the first 8 papers, filtering with the keywords \"sub multisets\".\n\nshelf = Shelf()\nshelf.query(keywords=\"sub multisets\", start_index=1, max_results=8)\n\n\npd.set_option('display.max_rows', 78)\ndf_multiset = shelf.get_authors_dataframe()\ndf_multiset\n\ndict_texts = shelf.fetch_texts()\npprint(dict_texts)\n"},"script_size":{"kind":"number","value":1461,"string":"1,461"}}},{"rowIdx":91,"cells":{"path":{"kind":"string","value":"/0_Functions.ipynb"},"content_id":{"kind":"string","value":"3729dbe48249b30387687824abb1e711d2114bcc"},"detected_licenses":{"kind":"list like","value":[],"string":"[]","isConversational":false},"license_type":{"kind":"string","value":"no_license"},"repo_name":{"kind":"string","value":"Ebanchous/Banks_insolvency_forecast_ML"},"repo_url":{"kind":"string","value":"https://github.com/Ebanchous/Banks_insolvency_forecast_ML"},"star_events_count":{"kind":"number","value":11,"string":"11"},"fork_events_count":{"kind":"number","value":0,"string":"0"},"gha_license_id":{"kind":"null"},"gha_event_created_at":{"kind":"null"},"gha_updated_at":{"kind":"null"},"gha_language":{"kind":"null"},"language":{"kind":"string","value":"Jupyter Notebook"},"is_generated":{"kind":"bool","value":false,"string":"false"},"is_vendor":{"kind":"bool","value":false,"string":"false"},"conversion_extension":{"kind":"string","value":".py"},"size":{"kind":"number","value":11121,"string":"11,121"},"script":{"kind":"string","value":"# ---\n# jupyter:\n# jupytext:\n# text_representation:\n# extension: .py\n# format_name: light\n# format_version: '1.5'\n# jupytext_version: 1.15.2\n# kernelspec:\n# display_name: Python 3\n# language: python\n# name: python3\n# ---\n\n# +\n# %%time\nimport pandas as pd\nprint('''по счетам погашенных кредитов (учтенных\nвекселей)''')\nredeemed_loans = pd.read_csv(r'C:\\Users\\DSimonov\\Desktop\\aa\\loans_pns.csv')\nredeemed_loans.head()\naccounts_loans = redeemed_loans['Acc'].astype(str).values.tolist()\n\nprint('''общему объему денежных средств, поступивших на корреспондентские счета кредитной\nорганизации (дебетовые обороты за месяц по счетам НОСТРО)''')\n\nnostro = pd.read_csv(r'C:\\Users\\DSimonov\\Desktop\\aa\\nostro.csv')\nnostro.head()\naccount_nostro = nostro['Acc'].astype(str).values.tolist()\n\n\n# +\ndef last_report_date(reg_number):\n date = max(df101.loc[df['regn'] == reg_number]['dt'])\n return date\n\ndef periods(reg_number):\n date = df101.loc[df101['regn'] == reg_number]['dt'].unique()\n date = pd.Series(date)\n date.sort_values(ascending=True, inplace=True)\n return date\n\ndef filter_bank(df, reg_num):\n df_regnum = df101.loc[df101['regn'] == reg_num]\n return df_regnum\n\ndef filter_date(df_regnum, date):\n df_regnum_date = df_regnum.loc[df_regnum['dt'].isin(date)]\n return df_regnum_date\n\ndef filtering(df101, reg_num, date):\n df_regnum = filter_bank(df101, reg_num)\n df_ready = filter_date(df_regnum, date)\n return df_ready\n\ndef status(reg_number):\n reg_number = int(reg_number)\n status = \"Operating\"\n date = max(df101.loc[df101['regn'] == reg_number]['dt'])\n date_overall = df101['dt'].unique()\n date_overall_value = max(date_overall)\n if date<date_overall_value:\n status = \"Liquidation\"\n return status\n\n\n# -\n\n# %%time\nreg_number = 880\naccounts_loans = redeemed_loans['Acc'].astype(str).values.tolist()\naccount_nostro = nostro['Acc'].astype(str).values.tolist()\ndate1 = periods(reg_number)[-2:]\nperiods1 = periods(reg_number)[-2:]\nprint(periods1)\nfor date in periods1[::-1]: \n date = str(date)[:10].split()\n df_total = filtering(df, reg_number, date)\n a = df_total.loc[df_total['num_sc'].isin(accounts_loans)]['iitg'].sum(axis = 0)\n b = df_total.loc[df_total['num_sc'].isin(account_nostro)]['oitga'].sum(axis = 0)\n print(f\"first value is {a}, the second value is {b}\")\n print (f'The coefficient is {\"{:.1%}\".format(a/b)}')\n\n# %%time\nimport pandas as pd\nbanks = df['regn'].unique()\nbanks = pd.Series(banks)\nbanks.sort_values(ascending=True, inplace=True)\nbanks.to_csv(r'C:\\Users\\DSimonov\\Desktop\\aa\\banks.csv', encoding = 'utf-8', index = False)\n\n\n# +\ndef periods_135(reg_number):\n date = df135.loc[df135['regn'] == reg_number]['dt'].unique()\n date = pd.Series(date)\n date.sort_values(ascending=True, inplace=True)\n return date\n\ndef filter_bank_135(df, reg_num):\n df_regnum_135 = df135.loc[df135['regn'] == reg_num]\n return df_regnum_135\n\ndef filter_date_135(df_regnum_135, date):\n df_regnum_date = df_regnum_135.loc[df_regnum_135['dt'].isin(date)]\n return df_regnum_date\n\ndef filtering_135(df135, reg_num, date):\n df_regnum_135 = filter_bank_135(df135, reg_num)\n df_ready_135 = filter_date_135(df_regnum_135, date)\n return df_ready_135\n\n\n# +\n# 'ova','oitga - обороты по дебету итого', 'orp', 'ovp','oitgp - обороты по кредиту итого', 'ir', 'iv','iitg - исходящие осттаки итого', 'dt', 'priz']\n# ['regn', 'plan', 'num_sc', 'a_p', 'vr', 'vv','vitg', 'ora', 'ova','oitga', 'orp', 'ovp','oitgp', 'ir', 'iv','iitg', 'dt', 'priz']\n\ndef core_function_1(df_total):\n try:\n a = df_total.loc[df_total['num_sc'].isin(numerator)]['oitgp'].sum(axis = 0)\n b = df_total.loc[df_total['num_sc'].isin(denominator)]['oitga'].sum(axis = 0)\n c= a/b\n except:\n c=0\n return c\n\ndef core_function_2(df_total_135):\n try:\n c= df_total_135.loc[df_total_135['code_norm'].str.contains(\"Н7\")]['act_norm'].values[0]\n except:\n c = 0\n return c\n\n\ndef core_function_3(df_total):\n try:\n a = df_total.loc[df_total['num_sc'].isin(numerator)]['oitga'].sum(axis = 0)\n b = df_total.loc[df_total['num_sc'].isin(denominator)]['oitgp'].sum(axis = 0)\n c= a/b\n except:\n c=0\n return c\n\n\n# -\n\n# %%time\n# Form 135\ncount = 1\nbank_coef_df = pd.DataFrame()\nfor bank in banks:\n print(f'Analysing RegNumber of Bank number {count} with regnumber {bank} out of {len(banks)} banks ({int(count/len(banks)*100)}% done)')\n periods_1 = periods_135(int(bank))[-12:]\n temp_coef_df = pd.DataFrame()\n for date in periods_1[::-1]:\n date = str(date)[:10].split()\n df_total_135 = filtering_135(df135, bank, date)\n c = core_function_2(df_total_135)\n# a = df_total.loc[df_total['num_sc'].isin(numerator)]['oitga'].sum(axis = 0)\n# b = df_total.loc[df_total['num_sc'].isin(denominator)]['oitgp'].sum(axis = 0)\n# c= a/b \n temp_coef_df = temp_coef_df.append({'bank': bank, 'date': date, 'coeff': c}, ignore_index=True)\n temp_coef_df = pd.DataFrame(temp_coef_df)\n temp_coef_df1 = temp_coef_df.transpose()\n temp_coef_df1 = temp_coef_df1.iloc[[1]]\n temp_coef_df1['bank'] = temp_coef_df.iloc[0,0]\n bank_coef_df = bank_coef_df.append(temp_coef_df1, ignore_index=True)\n count+=1\ncols = list(bank_coef_df.columns)\nbank_coef_df.columns =['recent', 'recent-1m', 'recent-2m', 'recent-3m', 'recent-4m',\n 'recent-5m', 'recent-6m', 'recent-7m','recent-8m', 'recent-9m', 'recent-10m','recent-11m', 'bank']\nbank_coef_df = bank_coef_df[['bank', 'recent', 'recent-1m', 'recent-2m', 'recent-3m', 'recent-4m',\n 'recent-5m', 'recent-6m', 'recent-7m', 'recent-8m', 'recent-9m', 'recent-10m', 'recent-11m']]\nbank_coef_df[bank_coef_df.columns[0]] = bank_coef_df[bank_coef_df.columns[0]].astype('int')\nbank_coef_df.columns =[ 'bank', 'recent', 'recent-1m', 'recent-2m', 'recent-3m', 'recent-4m',\n 'recent-5m', 'recent-6m', 'recent-7m','recent-8m', 'recent-9m', 'recent-10m','recent-11m']\n\n# %%time\naccounts_loans = redeemed_loans['Acc'].astype(str).values.tolist()\naccount_nostro = nostro['Acc'].astype(str).values.tolist()\nbank_coef_df = pd.DataFrame()\nfor bank in banks[:5]:\n print(f'Setting RegNumber of Bank with regnumber {bank}')\n periods_1 = periods(int(bank))[-12:]\n temp_coef_df = pd.DataFrame()\n for date in periods_1[::-1]:\n date = str(date)[:10].split()\n df_total = filtering(df101, bank, date)\n a = df_total.loc[df_total['num_sc'].isin(accounts_loans)]['iitg'].sum(axis = 0)\n b = df_total.loc[df_total['num_sc'].isin(account_nostro)]['oitga'].sum(axis = 0)\n c= a/b \n temp_coef_df = temp_coef_df.append({'bank': bank, 'date': date, 'coeff': c}, ignore_index=True)\n temp_coef_df = pd.DataFrame(temp_coef_df)\n temp_coef_df1 = temp_coef_df.transpose()\n temp_coef_df1 = temp_coef_df1.iloc[[1]]\n temp_coef_df1['bank'] = temp_coef_df.iloc[0,0]\n bank_coef_df = bank_coef_df.append(temp_coef_df1, ignore_index=True)\nre_order = [-1,0,1,2,3,4,5,6,7,8,9,10,11]\nbank_coef_df = bank_coef_df[bank_coef_df.columns[re_order]]\nbank_coef_df[bank_coef_df.columns[0]] = bank_coef_df[bank_coef_df.columns[0]].astype('int')\nbank_coef_df.columns =[ 'bank', 'recent', 'recent-1m', 'recent-2m', 'recent-3m', 'recent-4m',\n 'recent-5m', 'recent-6m', 'recent-7m','recent-8m', 'recent-9m', 'recent-10m','recent-11m']\n\n# %%time\ndf_accounts = pd.DataFrame()\ndf_accounts1 = pd.DataFrame()\ndf_accounts = df101.drop(['regn', 'plan', 'vr', 'vv','vitg', 'ora', 'ova','oitga', 'orp', 'ovp','oitgp','ir', 'iv','iitg', 'dt', 'priz'], axis=1)\ndf_accounts1= df_accounts.drop_duplicates(['num_sc', 'a_p'])\ndf_accounts1 = pd.DataFrame(df_accounts1)\ndf_accounts1.columns =['num_sc', 'a_p']\ndf_accounts1.to_csv(r'C:\\Users\\DSimonov\\Desktop\\aa\\accounts2.csv', encoding = 'utf-8', index = False)\n"},"script_size":{"kind":"number","value":8009,"string":"8,009"}}},{"rowIdx":92,"cells":{"path":{"kind":"string","value":"/HandsOnMachineLearning2_Chapter3.ipynb"},"content_id":{"kind":"string","value":"993f6177f5e342237c00be9acaa6b2e1c5a0123f"},"detected_licenses":{"kind":"list like","value":[],"string":"[]","isConversational":false},"license_type":{"kind":"string","value":"no_license"},"repo_name":{"kind":"string","value":"Jangsehawn/HandsOnMachineLearning2"},"repo_url":{"kind":"string","value":"https://github.com/Jangsehawn/HandsOnMachineLearning2"},"star_events_count":{"kind":"number","value":1,"string":"1"},"fork_events_count":{"kind":"number","value":0,"string":"0"},"gha_license_id":{"kind":"null"},"gha_event_created_at":{"kind":"null"},"gha_updated_at":{"kind":"null"},"gha_language":{"kind":"null"},"language":{"kind":"string","value":"Jupyter Notebook"},"is_generated":{"kind":"bool","value":false,"string":"false"},"is_vendor":{"kind":"bool","value":false,"string":"false"},"conversion_extension":{"kind":"string","value":".py"},"size":{"kind":"number","value":59606,"string":"59,606"},"script":{"kind":"string","value":"# ---\n# jupyter:\n# jupytext:\n# text_representation:\n# extension: .py\n# format_name: light\n# format_version: '1.5'\n# jupytext_version: 1.15.2\n# kernelspec:\n# display_name: Python 3\n# language: python\n# name: python3\n# ---\n\n# ## Capítulo 1.1.: Modelos estadísticos para control de calidad\n\n# ### Caso 1.1.1: Análisis de capacidad de proceso\n\nimport numpy as np\nimport math\nimport scipy.stats as st\n\n# ### Ejemplo 3:\n\n# Una característica de calidad importante en la fabricación de una llanta es la longitud de capa, que para cierto tipo de llanta debe ser de 870 mm con una tolerancia de $\\pm$ 7 mm. Para monitorear el correcto funcionamiento del proceso de corte, cada media hora se toman cinco (5) capas y se miden. De acuerdo a las mediciones realizadas el último mes, en donde el proceso ha estado trabajando de manera estable, se tiene que la media y la desviación estándar del proceso son $\\mu =$ 873 mm y $\\sigma =$ 2.5 mm, respectivamente. Con base a lo anterior se quiere saber en qué medida el proceso está cumpliendo con las especificaciones respondiendo a los siguientes interrogantes: \n# * **a) Determine la capacidad del proceso (Cp).**\n# * **b) ¿Cuál es la capacidad real del proceso (Cpk)?**\n# * **c) Calcule los límites de fluctiación natural del proceso (LFNP).**\n# * **d) ¿Qué proporción de producto no conforme se está generando por fuera de los límites de especificación?**\n# * **e) ¿Entre qué valores debería oscilar la media del proceso para que el porcentaje de no conformidad sea a lo sumo 4.0%?**\n\n# **a) Determine la capacidad del proceso (Cp):**\n\n# R/ Se sabe que el índice de capacidad del proceso Cp esta dado por:\n#\n# $$\\rightarrow C_{p}=\\frac{T}{6\\sigma'}$$\n#\n# Y:\n# $$\\rightarrow T = 2\\nabla = LSE - LIE$$\n#\n# Donde:\n# * $\\nabla$ es la discrepancia y de ahora en adelante se le asignará la letra 'D', \n# * $\\sigma'$ que es la desviación estándar se le asignará la letra 's',y \n# * 'T' es la tolerancia. \n#\n# A continuación se procederá determinar la capacidad del proceso:\n\n# +\nLIE = 870 - 7 # Límite Inferior de Especificación\nLSE = 870 + 7 # Límite Superior de Especificación\n\nT = LSE - LIE\n\ns = 2.5\n\nCp = T/(6*s)\nprint(Cp)\n# -\n\n# Dado que $0.67 < C_{p} < 1.00$ entonces esto por lo pronto indica que el proceso no tiene capacidad de fabricar producto dentro de las especificaciones, requiere modificaciones para generar producto que alcance una calidad satisfactoria.\n\n# **b) ¿Cuál es la capacidad real del proceso (Cpk)?**\n\n# R/ Cuando el proceso no está centrado, se emplea el **índice de capacidad unilateral** o **índice de capacidad real (Cpk)**:\n#\n# $$\\rightarrow C_{pk}=min(C_{pki}, C_{pks})$$\n#\n# $$\\rightarrow C_{pk}=min(C_{pki}=\\frac{\\bar{X'}-LIE}{3\\sigma'}, C_{pks}=\\frac{LSE-\\bar{X'}}{3\\sigma'})$$\n#\n# Donde:\n#\n# * $\\bar{X'}$ es la media del proceso, y\n# * $\\sigma'$ es la desviación del proceso.\n#\n# Por tanto, el índice Cpk es:\n\n# +\nX = 873\n\nCpki = np.round((X-LIE)/(3*s),2)\nCpks = np.round((LSE-X)/(3*s),2)\n\nCpk = np.min([Cpki,Cpks])\n\nprint(\"Cpki = \"+ str(Cpki))\nprint(\"Cpks = \"+ str(Cpks))\nprint(\"Cpk = \"+ str(Cpk))\n# -\n\n# Dado que Cpk $\\approx$ 0.53, esto indica que el proceso no es realmente capaz y por lo menos tiende a no cumplir con una de las especificaciones de calidad. Dicho lo anterior, tal parece que no se está cumpliendo con el límite superior de calidad, pues corresponde a Cpks $\\approx$ 0.53. Por el contrario, el proceso no parece tener problemas para cumplir con el límite inferior de especificación, ya que Cpki $\\approx$ 1.33.\n\n# **c) Calcule los límites de fluctuación natural del proceso (LFNP):**\n\n# R/ Se tiene que los límites de fluctuación natural del proceso están dados por la siguiente fórmula:\n#\n# $$\\rightarrow LFN_{i,s} = \\bar{X'} \\pm 3\\sigma'$$\n#\n# Donde:\n#\n# * $\\bar{X'}$ es la media del proceso, y\n# * $\\sigma'$ es la desviación estándar del proceso.\n#\n# Entonces, los límites de fluctuación son:\n\n# +\nLIFN = np.round(X - 3*s,4)\nLSFN = np.round(X + 3*s,4)\n\nprint(\"LIFN = \" + str(LIFN) + \" y LSFN = \" + str(LSFN))\n# -\n\n# Se compara si LIFN es mayor o igual a LIE y si LSFN es menor o igual a LSE:\n\nprint(LIFN>=LIE, LSFN<=LSE)\n\n# Se tiene que **el límite superior fluctuación natural (LIFN) es mas alto (>) que el límite superior de especificación (LSE)**, por lo que **se confirma que el proceso está generando producto no conforme por encima de dicho límite.**\n\n# **d) ¿Qué proporción de producto no conforme se está generando por fuera de los límites de especificación?**\n\n# R/ Como el proceso está generando producto no conforme por encima del límite superior de especificación, inicialmente se debe determinar el valor Z estandarizado para dicho límite. Esto se obtiene con la siguiente fórmula:\n#\n# $$\\rightarrow Z_{sup}=\\frac{LSE-\\bar{X'}}{\\sigma'}$$\n#\n# Obteniendo el siguiente resultado:\n\nZsup = np.round((LSE - X)/s,4)\nprint(Zsup)\n\n# Luego de esto, se obtiene de la tabla de distribución normal estándar la probabilidad de obtener un valor Zsup mayor a 1.6, así:\n\nP = np.round(1 - st.norm.cdf(Zsup),4)\nprint(P)\n\n# Es decir que la proporción de producto no conforme generado por encima del límite superior de especificación es del 5.48%. El porcentaje es bajo pero no despreciable, aproximadamente 548 unidades defectuosas en cada lote de 10.000 unidades, pero se podría mejorar centrando un poco más el proceso.\n\n# **e) ¿Entre qué valores debería oscilar la media del proceso para que el porcentaje de no conformidad sea a lo sumo 4.0%?**\n\n# Inicialmente se debe despejar $\\bar{X'}$ de la fórmula de Z estandarizado inferior, así:\n#\n# $$Z_{inf}=\\frac{LIE-\\bar{X'}}{\\sigma'}\\rightarrow\\bar{X'}_{inf}=LIE-\\sigma'Z_{inf}$$\n#\n# Lo mismo ocurre con la formula de Z estandarizado superior:\n#\n# $$Z_{sup}=\\frac{LSE-\\bar{X'}}{\\sigma'}\\rightarrow\\bar{X'}_{sup}=LSE-\\sigma'Z_{sup}$$\n#\n# Donde:\n# * $Z_{inf}$ es el valor de Z estandarizado inferior que representa una probabilidad de 4.0% de obtener producto no conforme por debajo de LIE, y\n# * $Z_{sup}$ es el valor de Z estandarizado superior que representa una probabilidad de 96.0% (100.0% - 4.0%) de no obtener inconformidades de producto por encima de LSE.\n#\n# Por lo tanto:\n\n# +\nVO_inf = 0.04\nZinf_vo = np.round(st.norm.ppf(VO_inf),4)\n\n\nVO_sup = 1 - VO_inf\nZsup_vo = np.round(st.norm.ppf(VO_sup),4)\n\nprint(\"Zinf = \"+str(Zinf_vo) + \" y Zsup = \" + str(Zsup_vo))\n# -\n\n# Entonces, los valores entre los cuales puede oscilar $\\bar{X'}$ para obtener a lo sumo 4.0% de producto no conforme son:\n\nXinf_vo = np.round(LIE - (Zinf_vo*s),1) # Cuando el proceso entrega 4% de producto no conforme por debajo del límite inferior de especificación.\nXsup_vo = np.round(LSE - (Zsup_vo*s),1) # Cuando el proceso entrega 4% de producto no conforme por encima del límite superior de especificación.\nprint(\"Xinf = \" + str(Xinf_vo) + \" y Xsup = \" + str(Xsup_vo))\n\n# Es decir, el proceso debe mejorar la exactitud debido a que la media del proceso debe oscilar entre 867.4 mm y 872.6 mm para obtener máximo 4% de no conformidades.\not_roc_curve(fpr_forest,tpr_forest, \"랜덤 포레스트\")\n# 랜포가 더 좋음 \n\n# # 3.6 다중 레이블 분류\n\n데이터 에 다중 레이블이 있는 것의 분류(사람 얼굴 여러개 등)\n\n# +\nfrom sklearn.neighbors import KNeighborsClassifier\n\ny_train_large=(y_train>=7) # 7보다 크거나 작은지\ny_train_odd=(y_train%2==1) # 홀수인지\ny_multilabel=np.c_[y_train_large,y_train_odd]\n\nknn_clf=KNeighborsClassifier()\nknn_clf.fit(X_train,y_multilabel)\n# -\n\nknn_clf.predict([some_digit]) # some_digit은 5이므로 둘다 맞음 ! \n\ny_train_knn_pred=cross_val_predict(knn_clf,X_train,y_multilabel,cv=3)\nf1_score(y_multilabel, y_train_knn_pred,average= \"macro\")# average=\"weighted\"로 클래스마다 가중치를 줄 수도 있음\n# 모든 레이블의 f1스코어의 평균을 계산함\n\n# # 3.7 다중 출력 분류 \n\n# 잡음이 많은 숫자를 입력받고 깨끗한 숫자이미지를 출력합니다 (다중 레이블(픽셀당 한레이블), 레이블이 값을 여러개 가짐(0~255))\n\nnoise = np.random.randint(0,100,len(X_train),784))\nX_train_mod=X_train+noise\nnoise = np.random.randint(0,100,len(X_test),784))\nX_test_mod=X_test+noise\ny_train_mod=X_train\ny_test_mod=X_test\n\n\nknn_clf.fit(X_train_mod,y_train_mod)\nclean_digit=knn_clf.predict([X_test_mod[some_index]])\nplot_digit(clean_digit)\n\n\n\n\n\n\n"},"script_size":{"kind":"number","value":8022,"string":"8,022"}}},{"rowIdx":93,"cells":{"path":{"kind":"string","value":"/python - time series.ipynb"},"content_id":{"kind":"string","value":"dfe9075c860dd8746e81acceedd0a3f74ea075b3"},"detected_licenses":{"kind":"list like","value":[],"string":"[]","isConversational":false},"license_type":{"kind":"string","value":"no_license"},"repo_name":{"kind":"string","value":"thomashuan88/python_ml"},"repo_url":{"kind":"string","value":"https://github.com/thomashuan88/python_ml"},"star_events_count":{"kind":"number","value":0,"string":"0"},"fork_events_count":{"kind":"number","value":0,"string":"0"},"gha_license_id":{"kind":"null"},"gha_event_created_at":{"kind":"null"},"gha_updated_at":{"kind":"null"},"gha_language":{"kind":"null"},"language":{"kind":"string","value":"Jupyter Notebook"},"is_generated":{"kind":"bool","value":false,"string":"false"},"is_vendor":{"kind":"bool","value":false,"string":"false"},"conversion_extension":{"kind":"string","value":".py"},"size":{"kind":"number","value":99513,"string":"99,513"},"script":{"kind":"string","value":"# ---\n# jupyter:\n# jupytext:\n# text_representation:\n# extension: .py\n# format_name: light\n# format_version: '1.5'\n# jupytext_version: 1.15.2\n# kernelspec:\n# display_name: Python 3\n# language: python\n# name: python3\n# ---\n\n# %pwd\n# https://stackabuse.com/time-series-analysis-with-lstm-using-pythons-keras-library/\n# https://towardsdatascience.com/time-series-in-python-exponential-smoothing-and-arima-processes-2c67f2a52788\n# https://towardsdatascience.com/time-series-in-python-part-2-dealing-with-seasonal-data-397a65b74051\n# https://towardsdatascience.com/time-series-in-python-part-3-forecasting-taxi-trips-with-lstms-277afd4f811\n# https://machinelearning.samcart.com/products/deep-learning-for-time-series-forecasting/\n# https://towardsdatascience.com/human-activity-recognition-har-tutorial-with-keras-and-core-ml-part-1-8c05e365dfa0\n\nimport pandas as pd\nappl_data = pd.read_csv(\"./AAPL.csv\")\nprint(appl_data.head())\nprint(appl_data.shape)\n\nappl_data.dtypes\n\nimport datetime\nimport requests\nfrom bokeh.plotting import figure, show, output_file\n\nappl_data['Date'] = pd.to_datetime(appl_data['Date'])\n\nappl_data = appl_data.sort_values(by=['Date'])\ndf = appl_data\n\n\n# +\nfrom math import pi\n\ninc = df.Close > df.Open\ndec = df.Open > df.Close\nw = 12*60*60*1000\nTOOLS = \"pan,wheel_zoom,box_zoom,reset,save\"\n\ntitle = 'AAPL' + ' chart'\np = figure(x_axis_type=\"datetime\", tools=TOOLS, plot_width=1000, title=title)\np.xaxis.major_label_orientation = pi/4\np.grid.grid_line_alpha=0.3\n\np.segment(df.Date, df.High, df.Date, df.Low, color=\"black\")\np.vbar(df.Date[inc], w, df.Open[inc], df.Close[inc], fill_color=\"#D5E1DD\", line_color=\"black\")\np.vbar(df.Date[dec], w, df.Open[dec], df.Close[dec], fill_color=\"#F2583E\", line_color=\"black\")\n\n#Store as a HTML file\noutput_file(\"stock_information.html\", title=\"candlestick example\")\n\nshow(p)\n\n# +\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport pandas as pd\nappl_data = pd.read_csv(\"./appl_train2.csv\")\nprint(appl_data.head())\nprint(appl_data.shape)\n\ndf = appl_data\ndf_training_processed = df.iloc[:, 1:2].values\n\ndf_training_processed\n\n# +\n# Data Normalization\n# As a rule of thumb, whenever you use a neural network, you should normalize or scale your data. \n# We will use MinMaxScaler class from the sklear.preprocessing library to scale our data between 0 and 1. \n# The feature_range parameter is used to specify the range of the scaled data. Execute the following script:\n\nfrom sklearn.preprocessing import MinMaxScaler\nscaler = MinMaxScaler(feature_range = (0,1))\n\ndf_training_scaled = scaler.fit_transform(df_training_processed)\n\n# +\nfeatures_set = []\nlabels = []\nfor i in range(60, 2460):\n features_set.append(df_training_scaled[i-60:i, 0])\n labels.append(df_training_scaled[i, 0])\n \nfeatures_set, labels = np.array(features_set), np.array(labels)\n\nprint(df_training_scaled[62,0])\nprint(df_training_scaled[0:4, 0])\nprint(labels)\n# -\n\nfeatures_set = np.reshape(features_set, (features_set.shape[0], features_set.shape[1], 1))\nfeatures_set.shape\n\nfrom keras.models import Sequential\nfrom keras.layers import Dense\nfrom keras.layers import LSTM\nfrom keras.layers import Dropout\n\n# +\nmodel = Sequential()\nmodel.add(LSTM(units=64, return_sequences=True, input_shape=(features_set.shape[1], 1)))\n# model.add(Dropout(0.2))\n\nmodel.add(LSTM(units=32))\n# model.add(LSTM(units=32, return_sequences=True))\nmodel.add(Dropout(0.2))\n\n# model.add(LSTM(units=50, return_sequences=True))\n# model.add(Dropout(0.2))\n\n# model.add(LSTM(units=50))\n# model.add(Dropout(0.2))\nmodel.add(Dense(units=16))\nmodel.add(Dense(units=1))\n\nmodel.compile(optimizer='adam', loss='mean_squared_error')\n\nprint(model.summary())\n\n# -\n\nmodel.fit(features_set, labels, epochs = 100, batch_size = 32)\n\napple_testing_complete = pd.read_csv('./appl_test2.csv')\napple_testing_complete = apple_testing_complete.iloc[0:10,:]\napple_testing_processed = apple_testing_complete.iloc[:, 1:2].values\n\n\n# +\nimport pandas as pd\nimport matplotlib.pyplot as plt\n\nfig, ax = plt.subplots(figsize=(15,10))\n\napple_testing_complete['Date'] = pd.to_datetime(apple_testing_complete['Date'])\nax.plot(apple_testing_complete['Date'],\n apple_testing_complete['Open'],\n color='red')\n\nplt.setp(ax.get_xticklabels(), rotation=45)\n\nax.set(xlabel='Date',\n ylabel='Open',\n title='app test open price')\n# -\n\napple_total = pd.concat((df['Open'], apple_testing_complete['Open']), axis=0)\napple_testing_complete.shape\n\ntest_inputs = apple_total[len(apple_total) - len(apple_testing_complete) - 60:].values\nprint(test_inputs.shape)\n\ntest_inputs = test_inputs.reshape(-1,1)\ntest_inputs = scaler.transform(test_inputs)\n\ntest_features = []\nfor i in range(60, 70):\n test_features.append(test_inputs[i-60:i, 0])\n\ntest_features = np.array(test_features)\nprint(test_features.shape)\n\n# +\n\ntest_features = np.reshape(test_features, (test_features.shape[0], test_features.shape[1], 1))\n\npredictions = model.predict(test_features)\n\npredictions = scaler.inverse_transform(predictions)\n\n# -\n\nplt.figure(figsize=(10,6))\nplt.plot(apple_testing_processed, color='blue', label='actual apple stock price')\nplt.plot(predictions, color='red', label='predicted appled stock price')\nplt.title('apple stock price prediction')\nplt.xlabel('Date')\nplt.ylabel('open price')\nplt.legend()\nplt.show()\n\n# https://medium.com/datadriveninvestor/multivariate-time-series-using-rnn-with-keras-7f78f4488679\n# https://towardsdatascience.com/choosing-the-right-hyperparameters-for-a-simple-lstm-using-keras-f8e9ed76f046\n\n"},"script_size":{"kind":"number","value":5537,"string":"5,537"}}},{"rowIdx":94,"cells":{"path":{"kind":"string","value":"/Simulation_state-based_2ndTask/MATLAB-Funktion_und_LyapunovBoundaryPlotting.ipynb"},"content_id":{"kind":"string","value":"d870ec543651a4bde549e81f911e1a39d0e80c81"},"detected_licenses":{"kind":"list like","value":["MIT"],"string":"[\n \"MIT\"\n]","isConversational":false},"license_type":{"kind":"string","value":"permissive"},"repo_name":{"kind":"string","value":"ipa-lth/jupyter_nb"},"repo_url":{"kind":"string","value":"https://github.com/ipa-lth/jupyter_nb"},"star_events_count":{"kind":"number","value":0,"string":"0"},"fork_events_count":{"kind":"number","value":2,"string":"2"},"gha_license_id":{"kind":"null"},"gha_event_created_at":{"kind":"timestamp","value":"2017-09-29T07:57:32","string":"2017-09-29T07:57:32"},"gha_updated_at":{"kind":"timestamp","value":"2016-12-13T10:42:20","string":"2016-12-13T10:42:20"},"gha_language":{"kind":"string","value":"Jupyter Notebook"},"language":{"kind":"string","value":"Jupyter Notebook"},"is_generated":{"kind":"bool","value":false,"string":"false"},"is_vendor":{"kind":"bool","value":false,"string":"false"},"conversion_extension":{"kind":"string","value":".py"},"size":{"kind":"number","value":16089,"string":"16,089"},"script":{"kind":"string","value":"# ---\n# jupyter:\n# jupytext:\n# text_representation:\n# extension: .py\n# format_name: light\n# format_version: '1.5'\n# jupytext_version: 1.15.2\n# kernelspec:\n# display_name: Python 3\n# language: python\n# name: python3\n# ---\n\n# # 机器学习工程师纳米学位\n# ## 模型评价与验证\n# ## 项目 1: 预测波士顿房价\n#\n#\n# 欢迎来到机器学习的预测波士顿房价项目！在此文件中，有些示例代码已经提供给你，但你还需要实现更多的功能来让项目成功运行。除非有明确要求，你无须修改任何已给出的代码。以**编程练习**开始的标题表示接下来的内容中有需要你必须实现的功能。每一部分都会有详细的指导，需要实现的部分也会在注释中以**TODO**标出。请仔细阅读所有的提示！\n#\n# 除了实现代码外，你还**必须**回答一些与项目和实现有关的问题。每一个需要你回答的问题都会以**'问题 X'**为标题。请仔细阅读每个问题，并且在问题后的**'回答'**文字框中写出完整的答案。你的项目将会根据你对问题的回答和撰写代码所实现的功能来进行评分。\n#\n# >**提示：**Code 和 Markdown 区域可通过 **Shift + Enter** 快捷键运行。此外，Markdown可以通过双击进入编辑模式。\n\n# ---\n# ## 第一步. 导入数据\n# 在这个项目中，你将利用马萨诸塞州波士顿郊区的房屋信息数据训练和测试一个模型，并对模型的性能和预测能力进行测试。通过该数据训练后的好的模型可以被用来对房屋做特定预测---尤其是对房屋的价值。对于房地产经纪等人的日常工作来说，这样的预测模型被证明非常有价值。\n#\n# 此项目的数据集来自[UCI机器学习知识库(数据集已下线)](https://archive.ics.uci.edu/ml/datasets.html)。波士顿房屋这些数据于1978年开始统计，共506个数据点，涵盖了麻省波士顿不同郊区房屋14种特征的信息。本项目对原始数据集做了以下处理：\n# - 有16个`'MEDV'` 值为50.0的数据点被移除。 这很可能是由于这些数据点包含**遗失**或**看不到的值**。\n# - 有1个数据点的 `'RM'` 值为8.78. 这是一个异常值，已经被移除。\n# - 对于本项目，房屋的`'RM'`， `'LSTAT'`，`'PTRATIO'`以及`'MEDV'`特征是必要的，其余不相关特征已经被移除。\n# - `'MEDV'`特征的值已经过必要的数学转换，可以反映35年来市场的通货膨胀效应。\n#\n# 运行下面区域的代码以载入波士顿房屋数据集，以及一些此项目所需的 Python 库。如果成功返回数据集的大小，表示数据集已载入成功。\n\n# +\n# Import libraries necessary for this project\nimport numpy as np\nimport pandas as pd\nfrom sklearn.model_selection import ShuffleSplit\n\n# Import supplementary visualizations code visuals.py\nimport visuals as vs\n\n# Pretty display for notebooks\n# %matplotlib inline\n\n# Load the Boston housing dataset\ndata = pd.read_csv('housing.csv')\nprices = data['MEDV']\nfeatures = data.drop('MEDV', axis = 1)\n \n# Success\nprint(\"Boston housing dataset has {} data points with {} variables each.\".format(*data.shape))\n\n# -\n\nmaximum_price = np.max(prices)\nprint(maximum_price)\n\n# ---\n# ## 第二步. 分析数据\n# 在项目的第一个部分，你会对波士顿房地产数据进行初步的观察并给出你的分析。通过对数据的探索来熟悉数据可以让你更好地理解和解释你的结果。\n#\n# 由于这个项目的最终目标是建立一个预测房屋价值的模型，我们需要将数据集分为**特征(features)**和**目标变量(target variable)**。\n# - **特征** `'RM'`， `'LSTAT'`，和 `'PTRATIO'`，给我们提供了每个数据点的数量相关的信息。\n# - **目标变量**：` 'MEDV'`，是我们希望预测的变量。\n#\n# 他们分别被存在 `features` 和 `prices` 两个变量名中。\n\n# ### 编程练习 1：基础统计运算\n# 你的第一个编程练习是计算有关波士顿房价的描述统计数据。我们已为你导入了 ` NumPy `，你需要使用这个库来执行必要的计算。这些统计数据对于分析模型的预测结果非常重要的。\n# 在下面的代码中，你要做的是：\n# - 计算 `prices` 中的 `'MEDV'` 的最小值、最大值、均值、中值和标准差；\n# - 将运算结果储存在相应的变量中。\n\n# +\n# TODO: Minimum price of the data\nminimum_price = np.min(prices)\n\n# TODO: Maximum price of the data\nmaximum_price = np.max(prices)\n\n# TODO: Mean price of the data\nmean_price = np.mean(prices)\n\n# TODO: Median price of the data\nmedian_price = np.median(prices)\n\n# TODO: Standard deviation of prices of the data\nstd_price = np.std(prices)\n\n# Show the calculated statistics\nprint(\"Statistics for Boston housing dataset:\\n\")\nprint(\"Minimum price: ${:.2f}\".format(minimum_price)) \nprint(\"Maximum price: ${:.2f}\".format(maximum_price))\nprint(\"Mean price: ${:.2f}\".format(mean_price))\nprint(\"Median price ${:.2f}\".format(median_price))\nprint(\"Standard deviation of prices: ${:.2f}\".format(std_price))\n# -\n\n# ### 问题 1 - 特征观察\n#\n# 如前文所述，本项目中我们关注的是其中三个值:`'RM'`、`'LSTAT'` 和`'PTRATIO'`，对每一个数据点:\n# - `'RM'` 是该地区中每个房屋的平均房间数量；\n# - `'LSTAT'` 是指该地区有多少百分比的业主属于是低收入阶层（有工作但收入微薄）；\n# - `'PTRATIO'` 是该地区的中学和小学里，学生和老师的数目比（`学生/老师`）。\n#\n# _凭直觉，上述三个特征中对每一个来说，你认为增大该特征的数值，`'MEDV'`的值会是**增大**还是**减小**呢？每一个答案都需要你给出理由。_\n#\n# **提示：**你预期一个`'RM'` 值是6的房屋跟`'RM'` 值是7的房屋相比，价值更高还是更低呢？\n\n# ### 问题 1 - 回答：\n# RM值越大，MEDV越大，因为房屋的平均房间数增多，房屋越大，价格也越贵。\n# LSTAT值也大，MEDV越小，因为低收入阶层占比越多，能负担得起的房屋价格越低，所以新建的房屋和二手房屋价格越低。\n# PTRATIO值越大，说明一个老师负责的学生相对越多，师资力量薄弱，说明学校的收入低下，对应地区的房屋价格也较低。\n\n# ---\n# ## 第三步. 建立模型\n# 在项目的第三步中，你需要了解必要的工具和技巧来让你的模型进行预测。用这些工具和技巧对每一个模型的表现做精确的衡量可以极大地增强你预测的信心。\n\n# ### 编程练习2：定义衡量标准\n# 如果不能对模型的训练和测试的表现进行量化地评估，我们就很难衡量模型的好坏。通常我们会定义一些衡量标准，这些标准可以通过对某些误差或者拟合程度的计算来得到。在这个项目中，你将通过运算[决定系数](https://en.wikipedia.org/wiki/Coefficient_of_determination) $R^2$ 来量化模型的表现。模型的决定系数是回归分析中十分常用的统计信息，经常被当作衡量模型预测能力好坏的标准。\n#\n# $R^2$ 的数值范围从0至1，表示**目标变量**的预测值和实际值之间的相关程度平方的百分比。一个模型的 $R^2$ 值为0还不如直接用**平均值**来预测效果好；而一个 $R^2$ 值为1的模型则可以对目标变量进行完美的预测。从0至1之间的数值，则表示该模型中目标变量中有百分之多少能够用**特征**来解释。模型也可能出现负值的 $R^2$，这种情况下模型所做预测有时会比直接计算目标变量的平均值差很多。\n#\n# 在下方代码的 `performance_metric` 函数中，你要实现：\n# - 使用 `sklearn.metrics` 中的 [`r2_score`](http://scikit-learn.org/stable/modules/generated/sklearn.metrics.r2_score.html) 来计算 `y_true` 和 `y_predict` 的 $R^2$ 值，作为对其表现的评判。\n# - 将他们的表现评分储存到 `score` 变量中。\n\n# TODO: Import 'r2_score'\nfrom sklearn.metrics import r2_score\ndef performance_metric(y_true, y_predict):\n \"\"\" Calculates and returns the performance score between \n true and predicted values based on the metric chosen. \"\"\"\n \n # TODO: Calculate the performance score between 'y_true' and 'y_predict'\n score = r2_score(y_true, y_predict)\n \n # Return the score\n return score\n\n\n# ### 问题 2 - 拟合程度\n#\n# 假设一个数据集有五个数据且一个模型做出下列目标变量的预测：\n#\n# | 真实数值 | 预测数值 |\n# | :-------------: | :--------: |\n# | 3.0 | 2.5 |\n# | -0.5 | 0.0 |\n# | 2.0 | 2.1 |\n# | 7.0 | 7.8 |\n# | 4.2 | 5.3 |\n# *你觉得这个模型已成功地描述了目标变量的变化吗？如果成功，请解释为什么，如果没有，也请给出原因。* \n#\n# **提示1**：运行下方的代码，使用 `performance_metric` 函数来计算 `y_true` 和 `y_predict` 的决定系数。\n#\n# **提示2**：$R^2$ 分数是指可以从自变量中预测的因变量的方差比例。 换一种说法：\n#\n# * $R^2$ 为0意味着因变量不能从自变量预测。\n# * $R^2$ 为1意味着可以从自变量预测因变量。\n# * $R^2$ 在0到1之间表示因变量可预测的程度。\n# * $R^2$ 为0.40意味着 Y 中40％的方差可以从 X 预测。\n\n# Calculate the performance of this model\nscore = performance_metric([3, -0.5, 2, 7, 4.2], [2.5, 0.0, 2.1, 7.8, 5.3])\nprint(\"Model has a coefficient of determination, R^2, of {:.3f}.\".format(score))\n\nfrom sklearn.model_selection import train_test_split\nprices = data['MEDV']\nfeatures = data.drop('MEDV', axis = 1)\nfeatures.shape,prices.shape\nX_train, X_test, y_train, y_test = train_test_split(features, prices, test_size=0.2, random_state=42)\n\n# ### 问题 2 - 回答:\n# R^2的分数高达92%以上，说明Y中92%的方差可以从X预测，这个模型能描述目标变量的变化。\n\n# ### 编程练习 3: 数据分割与重排\n# 接下来，你需要把波士顿房屋数据集分成训练和测试两个子集。通常在这个过程中，数据也会被重排列，以消除数据集中由于顺序而产生的偏差。\n# 在下面的代码中，你需要\n#\n# * 使用 `sklearn.model_selection` 中的 `train_test_split`， 将 `features` 和 `prices` 的数据都分成用于训练的数据子集和用于测试的数据子集。\n# - 分割比例为：80%的数据用于训练，20%用于测试；\n# - 选定一个数值以设定 `train_test_split` 中的 `random_state` ，这会确保结果的一致性；\n# * 将分割后的训练集与测试集分配给 `X_train`, `X_test`, `y_train` 和 `y_test`。\n\n# +\n# TODO: Import 'train_test_split'\nfrom sklearn.model_selection import train_test_split\n# TODO: Shuffle and split the data into training and testing subsets\nX_train, X_test, y_train, y_test = train_test_split(features, prices, test_size=0.2, random_state=42)\n\n# Success\nprint(\"Training and testing split was successful.\")\nX_train.shape, X_test.shape\n# -\n\n# ### 问题 3 - 训练及测试\n# *将数据集按一定比例分为训练用的数据集和测试用的数据集对学习算法有什么好处？*\n#\n# *如果用模型已经见过的数据，例如部分训练集数据进行测试，又有什么坏处？*\n#\n# **提示：** 如果没有数据来对模型进行测试，会出现什么问题？\n\n# ### 问题 3 - 回答:\n# 如果同一份数据集用来训练模型和测试模型，测试的结果会非常好，不能检测模型的拟合程度。用训练集来生成模型，然后用测试集来测试模型，才能检验出模型学习程度的拟合度和命中率。\n\n# ---\n# ## 第四步. 分析模型的表现\n# 在项目的第四步，我们来看一下不同参数下，模型在训练集和验证集上的表现。这里，我们专注于一个特定的算法（带剪枝的决策树，但这并不是这个项目的重点），和这个算法的一个参数 `'max_depth'`。用全部训练集训练，选择不同`'max_depth'` 参数，观察这一参数的变化如何影响模型的表现。画出模型的表现来对于分析过程十分有益。\n\n# ### 学习曲线\n# 下方区域内的代码会输出四幅图像，它们是一个决策树模型在不同最大深度下的表现。每一条曲线都直观得显示了随着训练数据量的增加，模型学习曲线的在训练集评分和验证集评分的变化，评分使用决定系数 $R^2$。曲线的阴影区域代表的是该曲线的不确定性（用标准差衡量）。\n#\n# 运行下方区域中的代码，并利用输出的图形回答下面的问题。\n\n# Produce learning curves for varying training set sizes and maximum depths\nvs.ModelLearning(features, prices)\n\n# ### 问题 4 - 学习曲线\n# * 选择上述图像中的其中一个，并给出其最大深度。\n# * 随着训练数据量的增加，训练集曲线的评分有怎样的变化？验证集曲线呢？\n# * 如果有更多的训练数据，是否能有效提升模型的表现呢？\n#\n# **提示：**学习曲线的评分是否最终会收敛到特定的值？一般来说，你拥有的数据越多，模型表现力越好。但是，如果你的训练和测试曲线以高于基准阈值的分数收敛，这是否有必要？基于训练和测试曲线已经收敛的前提下，思考添加更多训练点的优缺点。\n\n# ### 问题 4 - 回答:\n# 第一幅图中，最大深度是1\n# 训练集曲线的评分在50个点内下降很快，大于50个点后缓慢下降收敛于0.5左右。验证集曲线评分在50个点内上升很快，50个点后平稳于测试集分数0.5左右，两个得分都比较低。\n# 增加更多的训练数据并不能有效提升模型的表现，因为两者在300个样本之后就收敛于0.5这个比较低的分数，此时说明模型欠拟合，应该换其他深度更大的模型来提高命中率和拟合度。\n\n# ### 复杂度曲线\n# 下列代码内的区域会输出一幅图像，它展示了一个已经经过训练和验证的决策树模型在不同最大深度条件下的表现。这个图形将包含两条曲线，一个是训练集的变化，一个是验证集的变化。跟**学习曲线**相似，阴影区域代表该曲线的不确定性，模型训练和测试部分的评分都用的 `performance_metric` 函数。\n#\n# **运行下方区域中的代码，并利用输出的图形并回答下面的问题5与问题6。**\n\nvs.ModelComplexity(X_train, y_train)\n\n# ### 问题 5 - 偏差（bias）与方差（variance）之间的权衡取舍\n# * 当模型以最大深度 1训练时，模型的预测是出现很大的偏差还是出现了很大的方差？\n# * 当模型以最大深度10训练时，情形又如何呢？\n# * 图形中的哪些特征能够支持你的结论？\n# \n# **提示：** 高偏差表示欠拟合（模型过于简单），而高方差表示过拟合（模型过于复杂，以至于无法泛化）。考虑哪种模型（深度1或10）对应着上述的情况，并权衡偏差与方差。\n\n# ### 问题 5 - 回答:\n# 以最大深度为1训练时，模型预测出现高偏差，低方差。因为训练集和测试集分数都很低为0.4左右，说明命中率低。但是训练集和测试集的分数很接近，说明方差不大。\n# 以最大深度为10训练时，模型预测出现低偏差，高方差。因为训练集分数很高在0.9以上，说明命中率高，偏差低。但是测试集只有0.6左右，说明模型方差高，已经过拟合了。\n#\n\n# ### 问题 6- 最优模型的猜测\n# * 结合问题 5 中的图，你认为最大深度是多少的模型能够最好地对未见过的数据进行预测？\n# * 你得出这个答案的依据是什么？\n#\n# **提示**：查看问题5上方的图表，并查看模型在不同 `depth`下的验证分数。随着深度的增加模型的表现力会变得更好吗？我们在什么情况下获得最佳验证分数而不会使我们的模型过度复杂？请记住，奥卡姆剃刀：“在竞争性假设中，应该选择假设最少的那一个。”\n\n# ### 问题 6 - 回答:\n# 深度为3的模型能最好预测未见过的数据。两条曲线在深度1到3之间不断提高分数，3之后方差突然一下加大，训练集分数持续上升，测试集分数持续下降，说明模型在深度为3时两者的偏差和方差最理想的权衡状态。\n\n# ---\n# ## 第五步. 评估模型的表现\n# 在项目的最后一节中，你将构建一个模型，并使用 `fit_model` 中的优化模型去预测客户特征集。\n\n# ### 问题 7- 网格搜索（Grid Search）\n# * 什么是网格搜索法？\n# * 如何用它来优化模型？\n#\n# **提示**：在解释网格搜索算法时，首先要理解我们为什么使用网格搜索算法，以及我们使用它的最终目的是什么。为了使你的回答更具有说服力，你还可以给出一个模型中可以使用此方法进行优化参数的示例。\n\n# ### 问题 7 - 回答:\n# 有些模型具有多个超参数，多个超参数的值有多个不同的组合，我们用网格把这些参数值的组合列出，然后用交叉验证法，先用训练集训练拟合模型，再计算多个验证集的平均分数，然后再挑出表现最好的参数值组合（如果是命中率分数则取最高，如果是损失分数则取最低），然后再用测试集去验证挑出的模型参数值是否好。\n\n# ### 问题 8 - 交叉验证\n# - 什么是K折交叉验证法（k-fold cross-validation）？\n# - [GridSearchCV](http://scikit-learn.org/stable/modules/generated/sklearn.model_selection.GridSearchCV.html) 是如何结合交叉验证来完成对最佳参数组合的选择的？\n# - [GridSearchCV](http://scikit-learn.org/stable/modules/generated/sklearn.model_selection.GridSearchCV.html) 中的`'cv_results_'`属性能告诉我们什么？\n# - 网格搜索为什么要使用K折交叉验证？K折交叉验证能够避免什么问题？\n#\n# **提示**：在解释k-fold交叉验证时，一定要理解'k'是什么，和数据集是如何分成不同的部分来进行训练和测试的，以及基于'k'值运行的次数。\n# 在考虑k-fold交叉验证如何帮助网格搜索时，你可以使用特定的数据子集来进行训练与测试有什么缺点，以及K折交叉验证是如何帮助缓解这个问题。\n\n# ### 问题 8 - 回答：\n# 1.K折交叉验证法是把训练样本数据集平均分为K份，训练模型K次，每次把其中一份数据作为验证集，其他K-1份数据作为训练集，最后把K次验证的结果取平均值，最后用测试集来测试模型是否好。\n# 2.GridSearchCV中，把模型多个超参数列表作为参数整体传入，针对不同的参数组合用传入的K个训练集进行训练K次，验证K次，最后把K次验证的结果取平均值，得到结果最好的参数值组合。\n# 3.cv_results_ 属性按照参数值组合的不同，存在cv_results_['params']，并且存有交叉验证K轮的每一轮验证结果，'split0_test_score'作为第一轮验证结果，'split1_test_score'作为第二轮验证结果。。。'mean_test_score'作为每一轮结果平均值，'std_test_score'作为每一轮结果标准方差，还有最终基于平均值（'mean_test_score'）的排序结果cv_results_['rank_test_score']\n# 4.网格搜索有多个参数值组合，如果对于每一个参数值组合都简单的用同一份训练数据和同一份测试数据，可能会因为测试次数过少很难找出每个组合的优劣。用K折交叉验证法可以保证评估结果的稳定性和保真性，以选出最优的参数值组合的模型。\n\n# ### 编程练习 4：拟合模型\n# 在这个练习中，你将需要将所学到的内容整合，使用**决策树算法**训练一个模型。为了得出的是一个最优模型，你需要使用网格搜索法训练模型，以找到最佳的 `'max_depth'` 参数。你可以把`'max_depth'` 参数理解为决策树算法在做出预测前，允许其对数据提出问题的数量。决策树是**监督学习算法**中的一种。\n#\n# 另外，你会发现在实现的过程中是使用`ShuffleSplit()`作为交叉验证的另一种形式（参见'cv_sets'变量）。虽然它不是你在问题8中描述的K-fold交叉验证方法，但它同样非常有用！下面的`ShuffleSplit()`实现将创建10个('n_splits')混洗集合，并且对于每个混洗集，数据的20％（'test_size'）将被用作验证集合。当您在实现代码的时候，请思考一下它与`K-fold cross-validation`的不同与相似之处。\n#\n# 请注意，`ShuffleSplit` 在 `Scikit-Learn` 版本0.17和0.18中有不同的参数。对于下面代码单元格中的 `fit_model` 函数，您需要实现以下内容：\n#\n# 1. **定义 `'regressor'` 变量**: 使用 `sklearn.tree` 中的 [`DecisionTreeRegressor`](http://scikit-learn.org/stable/modules/generated/sklearn.tree.DecisionTreeRegressor.html) 创建一个决策树的回归函数;\n# 2. **定义 `'params'` 变量**: 为 `'max_depth'` 参数创造一个字典，它的值是从1至10的数组;\n# 3. **定义 `'scoring_fnc'` 变量**: 使用 `sklearn.metrics` 中的 [`make_scorer`](http://scikit-learn.org/stable/modules/generated/sklearn.metrics.make_scorer.html) 创建一个评分函数。将 `‘performance_metric’` 作为参数传至这个函数中；\n# 4. **定义 `'grid'` 变量**: 使用 `sklearn.model_selection` 中的 [`GridSearchCV`](http://scikit-learn.org/stable/modules/generated/sklearn.model_selection.GridSearchCV.html) 创建一个网格搜索对象；将变量`'regressor'`, `'params'`, `'scoring_fnc'`和 `'cross_validator'` 作为参数传至这个对象构造函数中；\n#\n# \n# 如果你对 Python 函数的默认参数定义和传递不熟悉，可以参考这个MIT课程的[视频](http://cn-static.udacity.com/mlnd/videos/MIT600XXT114-V004200_DTH.mp4)。\n\n# +\n# TODO: Import 'make_scorer', 'DecisionTreeRegressor', and 'GridSearchCV'\nfrom sklearn.model_selection import ShuffleSplit,GridSearchCV\nfrom sklearn.tree import DecisionTreeRegressor\nfrom sklearn.metrics import fbeta_score, make_scorer\n\n\ndef fit_model(X, y):\n \"\"\" Performs grid search over the 'max_depth' parameter for a \n decision tree regressor trained on the input data [X, y]. \"\"\"\n \n # Create cross-validation sets from the training data\n # sklearn version 0.18: ShuffleSplit(n_splits=10, test_size=0.1, train_size=None, random_state=None)\n # sklearn versiin 0.17: ShuffleSplit(n, n_iter=10, test_size=0.1, train_size=None, random_state=None)\n cv_sets = ShuffleSplit(n_splits=10, test_size=0.20, random_state=42)\n \n # TODO: Create a decision tree regressor object\n regressor = DecisionTreeRegressor()\n\n # TODO: Create a dictionary for the parameter 'max_depth' with a range from 1 to 10\n params = {'max_depth':[1,2,3,4,5,6,7,8,9,10]}\n\n # TODO: Transform 'performance_metric' into a scoring function using 'make_scorer' \n scoring_fnc = make_scorer(performance_metric)\n\n # TODO: Create the grid search cv object --> GridSearchCV()\n # Make sure to include the right parameters in the object:\n # (estimator, param_grid, scoring, cv) which have values 'regressor', 'params', 'scoring_fnc', and 'cv_sets' respectively.\n grid = GridSearchCV(regressor, params, scoring_fnc, cv=cv_sets)\n\n # Fit the grid search object to the data to compute the optimal model\n grid = grid.fit(X, y)\n\n # Return the optimal model after fitting the data\n return grid.best_estimator_\n\n\n# -\n\ncv_sets = ShuffleSplit(n_splits=10, test_size=0.20, random_state=42)\n\nregressor = DecisionTreeRegressor()\n\nparams = {'max_depth':[1,2,3,4,5,6,7,8,9,10]}\n\nscoring_fnc = make_scorer(performance_metric)\nscoring_fnc\n\ngrid = GridSearchCV(regressor, params, scoring_fnc, cv=cv_sets)\ngrid\n\ngrid =grid.fit(X_train, y_train)\n\ngrid.best_estimator_\n\n# ## 第六步. 做出预测\n# 当我们用数据训练出一个模型，它现在就可用于对新的数据进行预测。在决策树回归函数中，模型已经学会对新输入的数据*提问*，并返回对**目标变量**的预测值。你可以用这个预测来获取数据未知目标变量的信息，这些数据必须是不包含在训练数据之内的。\n\n# ### 问题 9 - 最优模型\n# *最优模型的最大深度（maximum depth）是多少？此答案与你在**问题 6**所做的猜测是否相同？*\n#\n# 运行下方区域内的代码，将决策树回归函数代入训练数据的集合，以得到最优化的模型。\n\n# +\n# Fit the training data to the model using grid search\nreg = fit_model(X_train, y_train)\n\n# Produce the value for 'max_depth'\n#print(\"Parameter 'max_depth' is {} for the optimal model.\".format(reg.get_params()['max_depth']))\n# -\n\nreg.get_params()['max_depth']\n\n# ### 问题 9 - 回答：\n# 最优模型的最大深度是3，和问题6作出的猜测是相同的。\n\n# ### 问题 10 - 预测销售价格\n# 想像你是一个在波士顿地区的房屋经纪人，并期待使用此模型以帮助你的客户评估他们想出售的房屋。你已经从你的三个客户收集到以下的资讯:\n#\n# | 特征 | 客戶 1 | 客戶 2 | 客戶 3 |\n# | :---: | :---: | :---: | :---: |\n# | 房屋内房间总数 | 5 间房间 | 4 间房间 | 8 间房间 |\n# | 社区贫困指数（％被认为是贫困阶层） | 17% | 32% | 3% |\n# | 邻近学校的学生-老师比例 | 15：1 | 22：1 | 12：1 |\n#\n# * 你会建议每位客户的房屋销售的价格为多少？\n# * 从房屋特征的数值判断，这样的价格合理吗？为什么？\n#\n# **提示：**用你在**分析数据**部分计算出来的统计信息来帮助你证明你的答案。\n#\n# 运行下列的代码区域，使用你优化的模型来为每位客户的房屋价值做出预测。\n\n# +\n# Produce a matrix for client data\nclient_data = [[5, 17, 15], # Client 1\n [4, 32, 22], # Client 2\n [8, 3, 12]] # Client 3\n\n# Show predictions\nfor i, price in enumerate(reg.predict(client_data)):\n print(\"Predicted selling price for Client {}'s home: ${:,.2f}\".format(i+1, price))\n# -\n\n# ### 问题 10 - 回答：\n# 会建议每位客户的房屋销售价格为这三个值：$345,707.55，$260,645.00，$903,393.75\n# 这样的价格是合理的：最贵的是客户3，房间数，社区贫困指数和学生老师比例这几个特征在样本数据中处于比平均水平要好很多的位置，因此它的价格比平均价格$454342.94和中位数$438900.00要高很多。中间的价格是客户1，房间数，社区贫困指数和学生老师比例在样本总体中都在中间位置偏下，价格因此要比平均值和中位值要低些。最便宜的是客户2，三个指数都最低，因此价格最便宜，比平均值和中位值要低很多。\n#\n\n# ### 编程练习 5\n# 你刚刚预测了三个客户的房子的售价。在这个练习中，你将用你的最优模型在整个测试数据上进行预测, 并计算相对于目标变量的决定系数 $R^2$ 的值。\n#\n# **提示：**\n# * 你可能需要用到 `X_test`, `y_test`, `optimal_reg`, `performance_metric`。\n# * 参考问题10的代码进行预测。\n# * 参考问题2的代码来计算R^2的值。\n#\n\n# +\n# TODO Calculate the r2 score between 'y_true' and 'y_predict'\nreg.fit(X_train, y_train)\ntrain_predict = reg.predict(X_train)\ntest_predict = reg.predict(X_test)\n\nr2 = performance_metric(y_train, train_predict)\nr2 = performance_metric(y_test, test_predict)\n\nprint(\"Optimal model has R^2 score {:,.2f} on test data\".format(r2))\n# -\n\n# ### 问题11 - 分析决定系数\n#\n# 你刚刚计算了最优模型在测试集上的决定系数，你会如何评价这个结果？\n\n# ### 问题11 - 回答\n# 测试集R^2的分数达到77%，说明Y中77%的方差可以从X预测，略低于训练集的82%，但两者已经很接近，说明这个模型能成功预测。\n\n# ### 模型健壮性\n#\n# 一个最优的模型不一定是一个健壮模型。有的时候模型会过于复杂或者过于简单，以致于难以泛化新增添的数据；有的时候模型采用的学习算法并不适用于特定的数据结构；有的时候样本本身可能有太多噪点或样本过少，使得模型无法准确地预测目标变量。这些情况下我们会说模型是欠拟合的。\n#\n# ### 问题 12 - 模型健壮性\n#\n# 模型是否足够健壮来保证预测的一致性？\n#\n# **提示**: 执行下方区域中的代码，采用不同的训练和测试集执行 `fit_model` 函数10次。注意观察对一个特定的客户来说，预测是如何随训练数据的变化而变化的。\n\nvs.PredictTrials(features, prices, fit_model, client_data)\n\n# ### 问题 12 - 回答：\n# 对同一个样本总体随机划分成训练集和测试集，划分10次，得到不同的训练集和测试集。而预测结果始终在$410,000上下波动，说明预测结果收敛于某个值，模型足够健壮。\n\n# ### 问题 13 - 实用性探讨\n# *简单地讨论一下你建构的模型能否在现实世界中使用？* \n#\n# 提示：回答以下几个问题，并给出相应结论的理由：\n# - *1978年所采集的数据，在已考虑通货膨胀的前提下，在今天是否仍然适用？*\n# - *数据中呈现的特征是否足够描述一个房屋？*\n# - *在波士顿这样的大都市采集的数据，能否应用在其它乡镇地区？*\n# - *你觉得仅仅凭房屋所在社区的环境来判断房屋价值合理吗？*\n\n# ### 问题 13 - 回答：\n# 1.在考虑通胀的情况下不适用，必须得用近期的价格样本总体去预测。\n# 2.一个房屋的特征除了模型中的三个特征值，还需要有其他的值，比如房屋建造成本，每年应征税赋，居民收入情况等。\n# 3.不能，因为乡镇地区的房屋所在社区环境跟波士顿截然不同。\n# 4.还需要考虑房屋建造成本，建造年份，维修费用等。\n\n# ## 第七步.完成和提交\n\n# 当你完成了以上所有的代码和问题，你需要将 iPython Notebook 导出 HTML，导出方法：在左上角的菜单中选择 **File -> Download as -> HTML (.html)**。当你提交项目时，需要包含**可运行的 .ipynb 文件**和**导出的 HTML 文件**。\n"},"script_size":{"kind":"number","value":16787,"string":"16,787"}}},{"rowIdx":95,"cells":{"path":{"kind":"string","value":"/EDA_with_Personal_Email_Analysis.ipynb"},"content_id":{"kind":"string","value":"36c6da0b0d1babfef7a64890b42d3bd2951dea13"},"detected_licenses":{"kind":"list like","value":[],"string":"[]","isConversational":false},"license_type":{"kind":"string","value":"no_license"},"repo_name":{"kind":"string","value":"omarn8911/Dphi-MLBootCamp"},"repo_url":{"kind":"string","value":"https://github.com/omarn8911/Dphi-MLBootCamp"},"star_events_count":{"kind":"number","value":0,"string":"0"},"fork_events_count":{"kind":"number","value":0,"string":"0"},"gha_license_id":{"kind":"null"},"gha_event_created_at":{"kind":"null"},"gha_updated_at":{"kind":"null"},"gha_language":{"kind":"null"},"language":{"kind":"string","value":"Jupyter Notebook"},"is_generated":{"kind":"bool","value":false,"string":"false"},"is_vendor":{"kind":"bool","value":false,"string":"false"},"conversion_extension":{"kind":"string","value":".py"},"size":{"kind":"number","value":1922595,"string":"1,922,595"},"script":{"kind":"string","value":"# ---\n# jupyter:\n# jupytext:\n# text_representation:\n# extension: .py\n# format_name: light\n# format_version: '1.5'\n# jupytext_version: 1.15.2\n# kernelspec:\n# display_name: Python 3\n# language: python\n# name: python3\n# ---\n\n# # 01_Tokenization of paragraphs_sentences\n\nimport nltk\n\n# +\n# APJ speech\n\nparagraph = \"\"\"I have three visions for India. In 3000 years of our history, people from all over \n the world have come and invaded us, captured our lands, conquered our minds. \n From Alexander onwards, the Greeks, the Turks, the Moguls, the Portuguese, the British,\n the French, the Dutch, all of them came and looted us, took over what was ours. \n Yet we have not done this to any other nation. We have not conquered anyone. \n We have not grabbed their land, their culture, \n their history and tried to enforce our way of life on them. \n Why? Because we respect the freedom of others.That is why my \n first vision is that of freedom. I believe that India got its first vision of \n this in 1857, when we started the War of Independence. It is this freedom that\n we must protect and nurture and build on. If we are not free, no one will respect us.\n My second vision for India’s development. For fifty years we have been a developing nation.\n It is time we see ourselves as a developed nation. We are among the top 5 nations of the world\n in terms of GDP. We have a 10 percent growth rate in most areas. Our poverty levels are falling.\n Our achievements are being globally recognised today. Yet we lack the self-confidence to\n see ourselves as a developed nation, self-reliant and self-assured. Isn’t this incorrect?\n I have a third vision. India must stand up to the world. Because I believe that unless India \n stands up to the world, no one will respect us. Only strength respects strength. We must be \n strong not only as a military power but also as an economic power. Both must go hand-in-hand. \n My good fortune was to have worked with three great minds. Dr. Vikram Sarabhai of the Dept. of \n space, Professor Satish Dhawan, who succeeded him and Dr. Brahm Prakash, father of nuclear material.\n I was lucky to have worked with all three of them closely and consider this the great opportunity of my life. \n I see four milestones in my career\"\"\"\n# -\n\n# Tokenizing sentences\nsentences = nltk.sent_tokenize(paragraph)\nlen(sentences)\n\nsentences\n\n# Tokenizing Words\nwords=nltk.word_tokenize(paragraph)\nlen(words)\n\n# # 02_Stemming\n#\n# Note: Stemming will stem to a root word, may or maynot be a meaningful word. \n#\n# Ex: \n#\n# History, Historical ==> Hotori \n# Finally, Final, Finalized ==> Fina \n# Go, Going, Gone ==> Go \n\n# +\nfrom nltk.stem import PorterStemmer # for stemming the words\nfrom nltk.corpus import stopwords # for removing stopwords\n\n# Stop workds like of for the then etc does not value much. Stop words will remove all these words\n# -\n\nstopwords.words('english')\n\nsentences_Stemmer = nltk.sent_tokenize(paragraph)\nlen(sentences_Stemmer)\n\n# Initilize Instance\nstemmer = PorterStemmer()\n\n# +\n# Stemming\n\nfor i in range(len(sentences_Stemmer)):\n words=nltk.word_tokenize(sentences_Lemmatize[i])\n # Below will stem only those words which are not in StopWords\n words=[stemmer.stem(word) for word in words if word not in set(stopwords.words('english'))]\n sentences_Stemmer[i]=' '.join(words)\n# -\n\nsentences_Stemmer\n# Below we can see we dont have stopwords in the sentence and\n# we have stemmed all the workds to a root word.\n\n# # 03_Lemmatization\n#\n# Lemmatization coverts to a meaningful word\n#\n# Ex: \n#\n# History, Historical ==> Hotory \n# Finally, Final, Finalized ==> Final \n# Go, Going, Gone ==> Go \n\nfrom nltk.stem import WordNetLemmatizer\nfrom nltk.corpus import stopwords\n\nsentences_Lemmatize = nltk.sent_tokenize(paragraph)\nlen(sentences_Lemmatize)\n\n# Creating an instance\nlemmatizer = WordNetLemmatizer()\n\nfor i in range(len(sentences_Lemmatize)):\n words = nltk.word_tokenize(sentences_Lemmatize[i])\n words =[lemmatizer.lemmatize(word) for word in words if word not in set(stopwords.words('english'))]\n sentences_Lemmatize[i]=' '.join(words)\n\nsentences_Lemmatize\n\n# ### NOTE\n#\n# Now you can compare all the three outputs and compare the outputs.\n#\n#\n# # 04_BagofWords\n#\n# It is a process of converting a sentence to a vector of 0s and 1s.\n#\n# Disadvantage: It gives equal importance to all words. Which is not good for sentimental analysis. For that we have **TF*IDF**\n\n# +\n# Cleaning the text\n\nimport re # This is regullar expression library\nfrom nltk.corpus import stopwords\nfrom nltk.stem import PorterStemmer\nfrom nltk.stem import WordNetLemmatizer\n\n# Creating instances\nps = PorterStemmer()\nwordnet = WordNetLemmatizer()\nsentences_BOW = nltk.sent_tokenize(paragraph)\ncorpus = []\n# -\n\nfor i in range(len(sentences_BOW)):\n # This below command from regullar exp. will only allow words with char a-z, A-Z ans spaces\n review = re.sub('[^a-zA-Z]', ' ', sentences_BOW[i])\n review = review.lower() #converting to lower case\n review = review.split()\n review = [ps.stem(word) for word in review if word not in set(stopwords.words('english'))]\n review = ' '.join(review)\n corpus.append(review)\n\n# Creating a BagOfWords model\nfrom sklearn.feature_extraction.text import CountVectorizer\ncv = CountVectorizer(max_features=1500)\nX = cv.fit_transform(corpus).toarray()\n\nX\n# you can see below all 31 sentences are converted to a Vector, using CountVectorizer library\n\n# # 05_TFIDF\n#\n# This is a very effective way in NLP where in each sentence, all workds are given a weitage based on TF*IDF formula\n\n# Cleaning the texts (This is the first step in every Natural Language processing project)\nimport re\nfrom nltk.corpus import stopwords\nfrom nltk.stem.porter import PorterStemmer\nfrom nltk.stem import WordNetLemmatizer\n\nps = PorterStemmer()\nwordnet=WordNetLemmatizer()\nsentences_TFIDF = nltk.sent_tokenize(paragraph)\ncorpus = []\nfor i in range(len(sentences_TFIDF)):\n review = re.sub('[^a-zA-Z]', ' ', sentences_TFIDF[i])\n review = review.lower()\n review = review.split()\n review = [wordnet.lemmatize(word) for word in review if not word in set(stopwords.words('english'))]\n review = ' '.join(review)\n corpus.append(review)\n\n# Creating the TFIDF model\nfrom sklearn.feature_extraction.text import TfidfVectorizer\ntfidf = TfidfVectorizer()\nY = tfidf.fit_transform(corpus).toarray()\n\nY\n# you can see there is a perticula weighage assigmend to each word\n\n\ne('%a, %d %b %Y %I:%M %p'))\nprint(dfs.index.max().strftime('%a, %d %b %Y %I:%M %p'))\n\nprint(dfs['label'].value_counts())\n\n# + colab_type=\"code\" id=\"ZnEhuNjjHJVe\" colab={}\nimport matplotlib.pyplot as plt\nfrom matplotlib.ticker import MaxNLocator\n# ticker module contains classes to support completely configurable tick locating and formatting.\n# MaxNLocator finds up to a max number of intervals with ticks at nice locations.\n\n# + colab_type=\"code\" id=\"r6NBjrTWC18s\" colab={}\n# This function might look complex and hard to understand\n# All it does is set how the plots will look\n# It first plots a scatter plot\n# It then adds the location of the ticks on x and y axis, labels and title\n# The scatter plot will only be drawn when the function is called\n\ndef plot_todo_vs_year(df, ax, color='C0', s=0.5, title=''):\n ind = np.zeros(len(df), dtype='bool')\n est = pytz.timezone('US/Eastern')\n \n df[~ind].plot.scatter('year', 'timeofday', s=s, alpha=0.6, ax=ax, color=color)\n ax.set_ylim(0, 24)\n ax.yaxis.set_major_locator(MaxNLocator(8))\n ax.set_yticklabels([datetime.datetime.strptime(str(int(np.mod(ts, 24))), \"%H\").strftime(\"%I %p\") for ts in ax.get_yticks()]);\n\n ax.set_xlabel('')\n ax.set_ylabel('')\n ax.set_title(title)\n ax.grid(ls=':', color='k')\n\n return ax\n\n\n# + colab_type=\"code\" id=\"P6Gwp9fcMboo\" colab={}\n#Let's create two sub-dataframe—one for sent emails and another for received emails:\n\nsent = dfs[dfs['label']=='sent']\nreceived = dfs[dfs['label']=='inbox']\n\n# + colab_type=\"code\" id=\"6V5ds-_rNtkb\" outputId=\"337bfc13-ab8e-455c-dcb7-e42599916bd5\" colab={\"base_uri\": \"https://localhost:8080/\", \"height\": 298}\nfig, ax = plt.subplots(nrows=1, ncols=2, figsize=(30, 8))\n\n# Since the function is called twice, one with sent and other with recieved as datapoints, 2 plots will be made\n\nplot_todo_vs_year(sent, ax[0], title='Sent')\nplot_todo_vs_year(received, ax[1], title='Received')\n\n\n# + [markdown] id=\"a3xnr1cLxiUf\" colab_type=\"text\"\n# The higher the density of the graph data points, the higher the number of emails. Note that the number of sent emails is less than the number of received emails. I received more emails than I sent from 2012 to 2020. Note that I received most of the emails between 03:00 PM and 03:00 AM. This graph gives a nice overview of the time of day of email activity. \n\n# + colab_type=\"code\" id=\"CcxH7jgtYCM6\" colab={}\n# Function to plot a histogram for average emails per day\ndef plot_number_perday_per_year(df, ax, label=None, dt=0.3, **plot_kwargs):\n year = df[df['year'].notna()]['year'].values\n T = year.max() - year.min()\n bins = int(T / dt)\n weights = 1 / (np.ones_like(year) * dt * 365.25)\n ax.hist(year, bins=bins, weights=weights, label=label, **plot_kwargs);\n ax.grid(ls=':', color='k')\n\n\n# + colab_type=\"code\" id=\"t205_eltYGWd\" colab={}\nfrom scipy import ndimage\n\n# Function to plot a histogram for average emails per hour\ndef plot_number_perdhour_per_year(df, ax, label=None, dt=1, smooth=False,\n weight_fun=None, **plot_kwargs):\n\n tod = df[df['timeofday'].notna()]['timeofday'].values\n year = df[df['year'].notna()]['year'].values\n Ty = year.max() - year.min()\n T = tod.max() - tod.min()\n bins = int(T / dt)\n if weight_fun is None:\n weights = 1 / (np.ones_like(tod) * Ty * 365.25 / dt)\n else:\n weights = weight_fun(df)\n if smooth:\n hst, xedges = np.histogram(tod, bins=bins, weights=weights);\n x = np.delete(xedges, -1) + 0.5*(xedges[1] - xedges[0])\n hst = ndimage.gaussian_filter(hst, sigma=0.75)\n f = interp1d(x, hst, kind='cubic')\n x = np.linspace(x.min(), x.max(), 10000)\n hst = f(x)\n ax.plot(x, hst, label=label, **plot_kwargs)\n else:\n ax.hist(tod, bins=bins, weights=weights, label=label, **plot_kwargs);\n\n\n ax.grid(ls=':', color='k')\n orientation = plot_kwargs.get('orientation')\n if orientation is None or orientation == 'vertical':\n ax.set_xlim(0, 24)\n ax.xaxis.set_major_locator(MaxNLocator(8))\n ax.set_xticklabels([datetime.datetime.strptime(str(int(np.mod(ts, 24))), \"%H\").strftime(\"%I %p\")\n for ts in ax.get_xticks()]);\n elif orientation == 'horizontal':\n ax.set_ylim(0, 24)\n ax.yaxis.set_major_locator(MaxNLocator(8))\n ax.set_yticklabels([datetime.datetime.strptime(str(int(np.mod(ts, 24))), \"%H\").strftime(\"%I %p\")\n for ts in ax.get_yticks()]);\n\n\n\n# + colab_type=\"code\" id=\"WQPZPs0wYKBE\" colab={}\n# This class specifies the location of each plot\nclass TriplePlot:\n def __init__(self):\n gs = gridspec.GridSpec(6, 6)\n self.ax1 = plt.subplot(gs[2:6, :4])\n self.ax2 = plt.subplot(gs[2:6, 4:6], sharey=self.ax1)\n plt.setp(self.ax2.get_yticklabels(), visible=False);\n self.ax3 = plt.subplot(gs[:2, :4]) \n plt.setp(self.ax3.get_xticklabels(), visible=False);\n\n def plot(self, df, color='darkblue', alpha=0.8, markersize=0.5, yr_bin=0.1, hr_bin=0.5):\n plot_todo_vs_year(df, self.ax1, color=color, s=markersize)\n plot_number_perdhour_per_year(df, self.ax2, dt=hr_bin, color=color, alpha=alpha, orientation='horizontal')\n self.ax2.set_xlabel('Average emails per hour')\n plot_number_perday_per_year(df, self.ax3, dt=yr_bin, color=color, alpha=alpha)\n self.ax3.set_ylabel('Average emails per day')\n\n\n# + colab_type=\"code\" id=\"q8a8CgVLYMtZ\" outputId=\"47775fb8-f18b-4a0e-e3c6-5b59fc265a02\" colab={\"base_uri\": \"https://localhost:8080/\", \"height\": 714}\nimport matplotlib.gridspec as gridspec\nimport matplotlib.patches as mpatches\n# Specifying the figure size and calling the function to plot the graphs\nplt.figure(figsize=(12,12));\ntpl = TriplePlot()\n\ntpl.plot(received, color='C0', alpha=0.3)\ntpl.plot(sent, color='C1', alpha=0.9)\np1 = mpatches.Patch(color='C0', label='Incoming', alpha=0.3)\np2 = mpatches.Patch(color='C1', label='Outgoing', alpha=0.9)\nplt.legend(handles=[p1, p2], bbox_to_anchor=[1.45, 0.7], fontsize=36, shadow=True);\n\n# + [markdown] id=\"OUZQAhIuxiU5\" colab_type=\"text\"\n# The average emails per hour and per graph is illustrated by the preceding graph. In my case, most email communication happened between 2018 and 2020. \n\n# + colab_type=\"code\" id=\"h67Gtw0wG-Et\" outputId=\"ccfe5768-3650-4fc8-d73e-02994ac35524\" colab={\"base_uri\": \"https://localhost:8080/\", \"height\": 333}\n# Counting the no. of emails received each day of the week and plotting a bar chart\ncounts = dfs.dayofweek.value_counts(sort=False)\ncounts.plot(kind='bar')\n\n# + [markdown] id=\"rC-eoPnpxiVD\" colab_type=\"text\"\n# The preceding output shows that my busiest day is Monday. I receive most of my emails on monday,tuesday. Lets go one step further and see the most active days for receiving and sending emails separately:\n\n# + colab_type=\"code\" id=\"FshoFdvXYeFT\" colab={} outputId=\"c03e053c-92d0-4536-cf79-345e10fee790\"\n# Finding out who sends me the most emails\n\naddrs = received['from'].value_counts()\n\naddrs[0:10]\n\n# + colab_type=\"code\" id=\"GT7De6EAyaBi\" outputId=\"883f2b91-0414-4f78-f5eb-04a95895f304\" colab={\"base_uri\": \"https://localhost:8080/\", \"height\": 714}\n# Plotting the above inferences in a Triple Plot\nplt.figure(figsize=(12,12));\n\ntpl = TriplePlot()\n\nlabels = []\ncolors = ['C{}'.format(ii) for ii in range(9)]\nidx = np.array([1,2,3,7])\nfor ct, addr in enumerate(addrs.index[idx]):\n tpl.plot(dfs[dfs['from'] == addr], color=colors[ct], alpha=0.3, yr_bin=0.5, markersize=1.0)\n labels.append(mpatches.Patch(color=colors[ct], label=addrs[0:4], alpha=0.5))\nplt.legend(handles=labels, bbox_to_anchor=[2.8, 0.2], fontsize=12, shadow=True);\n\n# + colab_type=\"code\" id=\"ONVxBNjcY7ca\" colab={} outputId=\"42f39177-1720-4827-c5d4-dd3b380d1ec5\"\n# Plotting bar chart with multiple values\n\nsdw = sent.groupby('dayofweek').size() / len(sent)\nrdw = received.groupby('dayofweek').size() / len(received)\n\ndf_tmp = pd.DataFrame(data={'Outgoing Email': sdw, 'Incoming Email':rdw})\ndf_tmp.plot(kind='bar', rot=45, figsize=(8,5), alpha=0.5)\nplt.xlabel('');\nplt.ylabel('Fraction of weekly emails');\nplt.grid(ls=':', color='k', alpha=0.5)\n\n# + [markdown] id=\"s2GR6whYxiVb\" colab_type=\"text\"\n# We can even go one level further. Let's find the most active time of day for email communication. We can do that easily. See the following code:\n\n# + colab_type=\"code\" id=\"M65qYDspZBPF\" outputId=\"a89693cb-2026-4157-d155-0d658694718a\" colab={\"base_uri\": \"https://localhost:8080/\", \"height\": 337}\nimport scipy.ndimage\nfrom scipy.interpolate import interp1d\n# Using the previously defined plot_number_perdhour_per_year function to find most active time of day\n\nplt.figure(figsize=(12,8))\nax = plt.subplot(111)\nfor ct, dow in enumerate(dfs.dayofweek.cat.categories):\n df_r = received[received['dayofweek']==dow]\n weights = np.ones(len(df_r)) / len(received)\n wfun = lambda x: weights\n plot_number_perdhour_per_year(df_r, ax, dt=1, smooth=True, color=f'C{ct}',\n alpha=0.8, lw=3, label=dow, weight_fun=wfun)\n\n df_s = sent[sent['dayofweek']==dow]\n weights = np.ones(len(df_s)) / len(sent)\n wfun = lambda x: weights\n plot_number_perdhour_per_year(df_s, ax, dt=1, smooth=True, color=f'C{ct}',\n alpha=0.8, lw=2, label=dow, ls='--', weight_fun=wfun)\nax.set_ylabel('Fraction of weekly emails per hour')\nplt.legend(bbox_to_anchor=[1.8, 0.2], fontsize=12, shadow=True)\n\n\n# + [markdown] id=\"nmq9LN1ixiVw\" colab_type=\"text\"\n# One of the easiest things to analyze about your emails is the most frequently used words. We can create a word cloud to see the most frequently used words. Let's first remove the archived emails:\n\n# + id=\"MnF03SYUxiVx\" colab_type=\"code\" colab={} outputId=\"8da009fa-5741-4d6e-d4ec-d7c86e8e3320\"\n# !pip install WordCloud\n# cloud filled with lots of words in different sizes, which represent the frequency or the importance of each word.\n\n# + colab_type=\"code\" id=\"S0XobdERZqQy\" colab={}\nfrom wordcloud import WordCloud \n\ntext = ' '.join(map(str, dfs['subject'].values))\n\n# + colab_type=\"code\" id=\"kbUU2K_BZssY\" outputId=\"6be77593-f19f-43c0-85ea-1649fd26836d\" colab={\"base_uri\": \"https://localhost:8080/\", \"height\": 846}\nstopwords = ['Re', 'Fwd', '3A_']\nwrd = WordCloud(width=700, height=480, margin=0, collocations=False)\nfor sw in stopwords:\n wrd.stopwords.add(sw)\nwordcloud = wrd.generate(text)\n\nplt.figure(figsize=(25,15))\nplt.imshow(wordcloud, interpolation='bilinear')\nplt.axis(\"off\")\nplt.margins(x=0, y=0)\n\n# + [markdown] id=\"iaKw4OMxxiWQ\" colab_type=\"text\"\n# This tells me what I mostly communicate about. From the analysis of emails from 2012 to 2020, the most frequently used words are Regarding, India, new, Data, job, and learning. This is really good, right? What is presented in this notebook is just a starting point. You can take this further in several other directions. \n"},"script_size":{"kind":"number","value":17555,"string":"17,555"}}},{"rowIdx":96,"cells":{"path":{"kind":"string","value":"/qqplot/qqplot_no2.ipynb"},"content_id":{"kind":"string","value":"707a3604ea491e10729542cf1804bd9840d84f83"},"detected_licenses":{"kind":"list like","value":[],"string":"[]","isConversational":false},"license_type":{"kind":"string","value":"no_license"},"repo_name":{"kind":"string","value":"saireddythfc/Air-Quality-Index-Analysis"},"repo_url":{"kind":"string","value":"https://github.com/saireddythfc/Air-Quality-Index-Analysis"},"star_events_count":{"kind":"number","value":0,"string":"0"},"fork_events_count":{"kind":"number","value":0,"string":"0"},"gha_license_id":{"kind":"null"},"gha_event_created_at":{"kind":"timestamp","value":"2019-12-03T12:31:28","string":"2019-12-03T12:31:28"},"gha_updated_at":{"kind":"timestamp","value":"2019-12-03T12:28:37","string":"2019-12-03T12:28:37"},"gha_language":{"kind":"null"},"language":{"kind":"string","value":"Jupyter Notebook"},"is_generated":{"kind":"bool","value":false,"string":"false"},"is_vendor":{"kind":"bool","value":false,"string":"false"},"conversion_extension":{"kind":"string","value":".py"},"size":{"kind":"number","value":33812,"string":"33,812"},"script":{"kind":"string","value":"# ---\n# jupyter:\n# jupytext:\n# text_representation:\n# extension: .py\n# format_name: light\n# format_version: '1.5'\n# jupytext_version: 1.15.2\n# kernelspec:\n# display_name: Python 3\n# language: python\n# name: python3\n# ---\n\nimport pandas as pd\nimport numpy as np\nfrom scipy.special import ndtri\nimport matplotlib.pyplot as plt \n\n# +\ndf2 = pd.read_excel(r'/home/pragya/fyp/abc_median.xlsx')\n\ndf2 = df2.sort_values(by=['no2'],ascending=True).reset_index()\n\ndf2['count2'] = df2.index + 1\n\nn_rows2 = df2.shape[0]\n\ndf2['percentile_area2'] = (df2['count2'])/n_rows2\n\ndf2['z_theoritical2'] = ndtri(df2['percentile_area2'])\n\ndf2['z_actual2'] = (df2['no2']-df2['no2'].mean())/df2['no2'].std(ddof=0)\n\ndf2.head()\n\n# +\ndf1 = pd.read_excel(r'/home/pragya/fyp/abc_1.xlsx')\n\ndf1 = df1.sort_values(by=['no2'],ascending=True).reset_index()\n\ndf1['count1'] = df1.index + 1\n\nn_rows1 = df1.shape[0]\n\ndf1['percentile_area1'] = (df1['count1'])/n_rows1\n\ndf1['z_theoritical1'] = ndtri(df1['percentile_area1'])\n\ndf1['z_actual1'] = (df1['no2']-df1['no2'].mean())/df1['no2'].std(ddof=0)\n\ndf1.head()\n# -\n\nplt.scatter(df1.z_actual1, df1.z_theoritical1, c=\"g\",alpha = 0.5, marker=r'$\\clubsuit$',label=\"Mean\")\nplt.scatter(df2.z_actual2, df2.z_theoritical2, c=\"r\", alpha = 0.5, marker='x',label=\"Median\")\nplt.plot([-3,-2,-1,0,1,2,3],[-3,-2,-1,0,1,2,3])\n\n\n"},"script_size":{"kind":"number","value":1364,"string":"1,364"}}},{"rowIdx":97,"cells":{"path":{"kind":"string","value":"/12_solid.ipynb"},"content_id":{"kind":"string","value":"524d3babf7138fd79b24acffd7683bf8e31f99cc"},"detected_licenses":{"kind":"list like","value":[],"string":"[]","isConversational":false},"license_type":{"kind":"string","value":"no_license"},"repo_name":{"kind":"string","value":"SalmonMoses/oop2020"},"repo_url":{"kind":"string","value":"https://github.com/SalmonMoses/oop2020"},"star_events_count":{"kind":"number","value":0,"string":"0"},"fork_events_count":{"kind":"number","value":0,"string":"0"},"gha_license_id":{"kind":"null"},"gha_event_created_at":{"kind":"timestamp","value":"2021-05-08T21:33:31","string":"2021-05-08T21:33:31"},"gha_updated_at":{"kind":"timestamp","value":"2021-04-17T20:27:40","string":"2021-04-17T20:27:40"},"gha_language":{"kind":"string","value":"Jupyter Notebook"},"language":{"kind":"string","value":"Jupyter Notebook"},"is_generated":{"kind":"bool","value":false,"string":"false"},"is_vendor":{"kind":"bool","value":false,"string":"false"},"conversion_extension":{"kind":"string","value":".py"},"size":{"kind":"number","value":25000,"string":"25,000"},"script":{"kind":"string","value":"# ---\n# jupyter:\n# jupytext:\n# text_representation:\n# extension: .py\n# format_name: light\n# format_version: '1.5'\n# jupytext_version: 1.15.2\n# kernelspec:\n# display_name: Python 3\n# name: python3\n# ---\n\n# + [markdown] id=\"GBgYUDM7VwUm\"\n# # ThinkDSP课后习题\n\n# + [markdown] id=\"AE5o0EYiV4SU\"\n# ## 第一章：声音与信号\n\n# + colab={\"base_uri\": \"https://localhost:8080/\"} executionInfo={\"elapsed\": 3138, \"status\": \"ok\", \"timestamp\": 1615735803061, \"user\": {\"displayName\": \"Chuanchao Xu\", \"photoUrl\": \"\", \"userId\": \"08016207472332924278\"}, \"user_tz\": -480} id=\"dyhumJvjVpKI\" outputId=\"c26e20a0-3450-4c1f-f564-c526f6f71bb8\"\nimport os\nif not os.path.exists('170255__dublie__trumpet.wav'):\n # !wget https://github.com/AllenDowney/ThinkDSP/raw/master/code/170255__dublie__trumpet.wav\n\n# + colab={\"base_uri\": \"https://localhost:8080/\"} executionInfo={\"elapsed\": 4733, \"status\": \"ok\", \"timestamp\": 1615735866398, \"user\": {\"displayName\": \"Chuanchao Xu\", \"photoUrl\": \"\", \"userId\": \"08016207472332924278\"}, \"user_tz\": -480} id=\"xB3vFO0eWwjr\" outputId=\"7031f79f-a8b4-49dc-b441-a073ff43a745\"\nif not os.path.exists('thinkdsp.py'):\n # !wget https://github.com/AllenDowney/ThinkDSP/raw/master/code/thinkdsp.py\n\n# + colab={\"background_save\": true} id=\"_27nHHohXOZx\"\nfrom thinkdsp import read_wave\nwave = read_wave('170255__dublie__trumpet.wav')\nwave.normalize()\nwave_make_audio()\npam_filter.png)\n\n# **Unsupervised learning**: Extracting structure from data or learning how to best represent data.\n#\n# - Example: If dataset was the characteristics and purchasing behaviour of shoppers at a grocery store, the unsupervised learning task might be to segment grocery store shoppers into groups or clusters that exhibit similar behaviors.\n# - There is no \"right answer\"\n\n# \n\n# ## How does machine learning \"work\"?\n#\n# High-level steps of supervised learning:\n#\n# 1. First, train a **machine learning model** using **labeled data**\n#\n# - \"Labeled data\" has been labeled with the outcome. (eg. whether the email is 'spam' or 'ham')\n# - This is called model training because the model is learning the relationship between the attributes of the data and the outcome. (eg. Attributes can be email message text, length of message, no. of embedded links etc)\n# - \"Machine learning model\" learns the relationship between the attributes of the data and its outcome\n# \n# 2. Then, make **predictions** on **new data** for which the label is unknown\n\n# \n\n# The primary goal of supervised learning is to build a model that \"generalizes\": It accurately predicts the **future** rather than the **past**!\n\n# ## Questions about machine learning\n#\n# - How do I choose **which attributes** of my data to include in the model?\n# - How do I choose **which model** to use?\n# - How do I **optimize** this model for best performance?\n# - How do I ensure that I'm building a model that will **generalize** to unseen data?\n# - Can I **estimate** how well my model is likely to perform on unseen data?\n\n# ## Resources\n#\n# - Book: [An Introduction to Statistical Learning](http://www-bcf.usc.edu/~gareth/ISL/) (section 2.1, 14 pages)\n# - Video: [Learning Paradigms](http://work.caltech.edu/library/014.html) (13 minutes)\n\n# ## Comments or Questions?\n#\n# - Email: <kevin@dataschool.io>\n# - Website: http://dataschool.io\n# - Twitter: [@justmarkham](https://twitter.com/justmarkham)\n\nfrom IPython.core.display import HTML\ndef css_styling():\n styles = open(\"styles/custom.css\", \"r\").read()\n return HTML(styles)\ncss_styling()\nможу так: пікпікпік!!!')\n elif animal.name == 'Змія':\n print('я можу так: шшшшшшшш !!!')\n\n\ndef main():\n\n animals = [\n Animal('Лев'),\n Animal('Миша'),\n Animal('Змія')\n ]\n\n animal_sound(animals)\n \n\n\nif __name__ == '__main__':\n main()\n\n\n# +\n#3-n\nclass Discount:\n def __init__(self, customer, price):\n self.customer = customer\n self.price = price\n\n def get_discount(self):\n if self.customer == 'звичайний':\n return self.price * 0.2\n if self.customer == 'ВІП':\n return self.price * 0.4\n\n\ndef main():\n\n customer1, price1 = 'звичайний', 100\n assert Discount(customer1, price1).get_discount() == 20.0\n\n customer2, price2 = 'ВІП', 100\n assert Discount(customer2, price2).get_discount() == 40.0\n \n print(customer1, price1)\n print(customer2, price2)\n \n \nif __name__ == '__main__':\n main()\n\n\n# +\n#1.1-y\nclass Animal:\n def __init__(self, name: str):\n self.name = name\n\n def get_name(self) -> str:\n return f'Мене звуть : {self.name}'\n\n def make_sound(self):\n pass\n\n\nclass Lion(Animal):\n def make_sound(self):\n return 'я можу так: рррррррр!!!'\n\n\nclass Mouse(Animal):\n def make_sound(self):\n return 'я можу так: пікпікпік!!!'\n\n\ndef animal_sound(animals: list):\n for animal in animals:\n print(animal.make_sound())\n\n\ndef main():\n\n animals = [\n Lion('Лев'),\n Mouse('Миша')\n \n ]\n\n animal_sound(animals)\n\n\nif __name__ == '__main__':\n main()\n\n\n# +\n#1.1-y\nclass Animal:\n def __init__(self, name: str):\n self.name = name\n\n def get_name(self) -> str:\n return f'Мене звуть : {self.name}'\n\n def make_sound(self):\n pass\n\n\nclass Lion(Animal):\n def make_sound(self):\n return 'я можу так: рррррррр!!!'\n\n\nclass Mouse(Animal):\n def make_sound(self):\n return 'я можу так: пікпікпік!!!'\n\nclass Snake(Animal):\n def make_sound(self):\n return 'я можу так: шшшшшшшш !!!'\n \ndef animal_sound(animals: list):\n for animal in animals:\n print(animal.make_sound())\n\n\ndef main():\n\n animals = [\n Lion('Лев'),\n Mouse('Миша'),\n Snake('Змія')\n \n ]\n\n animal_sound(animals)\n\n\nif __name__ == '__main__':\n main()\n\n\n# +\n#2.1-y\nclass Animal:\n def __init__(self, name: str):\n self.name = name\n\n def get_name(self) -> str:\n return f'Мене звуть : {self.name}'\n\n def make_sound(self):\n pass\n\n\nclass Lion(Animal):\n def make_sound(self):\n return 'я можу так: рррррррр!!!'\n\n\nclass Mouse(Animal):\n def make_sound(self):\n return 'я можу так: пікпікпік!!!'\n\n\nclass Snake(Animal):\n def make_sound(self):\n return 'я можу так: шшшшшшшш !!!'\n\n\ndef animal_sound(animals: list):\n for animal in animals:\n print(animal.make_sound())\n\n\ndef main():\n\n animals = [\n Lion('Лев'),\n Mouse('Миша'),\n Snake('Питон')\n ]\n\n animal_sound(animals)\n\n\nif __name__ == '__main__':\n main()\n\n\n# +\n#3.1-y\nclass Discount:\n def __init__(self, customer, price):\n self.customer = customer\n self.price = price\n\n def get_discount(self):\n return self.price * 0.2\n\n\nclass VIPDiscount(Discount):\n def get_discount(self):\n return super().get_discount() * 2\n\n\nclass SuperVIPDiscount(VIPDiscount):\n def get_discount(self):\n return super().get_discount() * 2\n\n\ndef main():\n\n customer, price = 'Лютий', 100\n\n assert Discount(customer, price).get_discount() == 20.0\n assert VIPDiscount(customer, price).get_discount() == 40.0\n assert SuperVIPDiscount(customer, price).get_discount() == 80.0\n\n\nif __name__ == '__main__':\n main()\n# -\n\n# ## Liskov\n\n# +\n#1 \nDEFAULT_LION_LEG_COUNT = 4\nDEFAULT_MOUSE_LEG_COUNT = 4\nDEFAULT_SNAKE_LEG_COUNT = 0\n\nclass Animal:\n pass\n\nclass Lion(Animal):\n pass\n\nclass Mouse(Animal):\n pass\n\nclass Snake(Animal):\n pass\n\ndef animal_leg_count(animals: list):\n for animal in animals:\n if isinstance(animal, Lion):\n print(DEFAULT_LION_LEG_COUNT)\n elif isinstance(animal, Mouse):\n print(DEFAULT_MOUSE_LEG_COUNT)\n elif isinstance(animal, Snake):\n print(DEFAULT_SNAKE_LEG_COUNT)\n\ndef main():\n\n animals = [\n Lion(),\n Mouse(),\n Snake()\n ]\n\n animal_leg_count(animals)\n\nif __name__ == '__main__':\n main()\n\n# +\n#1+crocodile \nDEFAULT_LION_LEG_COUNT = 4\nDEFAULT_MOUSE_LEG_COUNT = 4\nDEFAULT_SNAKE_LEG_COUNT = 0\nDEFAULT_CROCODILE_LEG_COUNT = 4\n\nclass Animal:\n pass\n\nclass Lion(Animal):\n pass\n\nclass Mouse(Animal):\n pass\n\nclass Snake(Animal):\n pass\n\nclass Crocodile(Animal):\n pass\n\ndef animal_leg_count(animals: list):\n for animal in animals:\n if isinstance(animal, Lion):\n print(DEFAULT_LION_LEG_COUNT)\n elif isinstance(animal, Mouse):\n print(DEFAULT_MOUSE_LEG_COUNT)\n elif isinstance(animal, Snake):\n print(DEFAULT_SNAKE_LEG_COUNT)\n elif isinstance(animal, Crocodile):\n print(DEFAULT_CROCODILE_LEG_COUNT)\n\ndef main():\n\n animals = [\n Lion(),\n Mouse(),\n Snake(),\n Crocodile()\n ]\n\n animal_leg_count(animals)\n\nif __name__ == '__main__':\n main()\n\n# +\n#1.1-y\nDEFAULT_LION_LEG_COUNT = 4\nDEFAULT_MOUSE_LEG_COUNT = 4\nDEFAULT_SNAKE_LEG_COUNT = 0\n\nclass Animal:\n def get_legs_count(self):\n pass\n\nclass Lion(Animal):\n def get_legs_count(self):\n return DEFAULT_LION_LEG_COUNT\n\nclass Mouse(Animal):\n def get_legs_count(self):\n return DEFAULT_MOUSE_LEG_COUNT\n\nclass Snake(Animal):\n def get_legs_count(self):\n return DEFAULT_SNAKE_LEG_COUNT\n\n\ndef animal_leg_count(animals: list):\n for animal in animals:\n print(animal.get_legs_count())\n\ndef main():\n\n animals = [\n Lion(),\n Mouse(),\n Snake()\n ]\n\n animal_leg_count(animals)\n\n\nif __name__ == '__main__':\n main()\n\n# +\n#1.1-y\nDEFAULT_LION_LEG_COUNT = 4\nDEFAULT_MOUSE_LEG_COUNT = 4\nDEFAULT_SNAKE_LEG_COUNT = 0\nDEFAULT_CROCODILE_LEG_COUNT = 4\n\nclass Animal:\n def get_legs_count(self):\n pass\n\nclass Lion(Animal):\n def get_legs_count(self):\n return DEFAULT_LION_LEG_COUNT\n\nclass Mouse(Animal):\n def get_legs_count(self):\n return DEFAULT_MOUSE_LEG_COUNT\n\nclass Snake(Animal):\n def get_legs_count(self):\n return DEFAULT_SNAKE_LEG_COUNT\n\nclass Crocodile(Animal):\n def get_legs_count(self):\n return DEFAULT_CROCODILE_LEG_COUNT\n\n \ndef animal_leg_count(animals: list):\n for animal in animals:\n print(animal.get_legs_count())\n\ndef main():\n\n animals = [\n Lion(),\n Mouse(),\n Snake(),\n Crocodile()\n ]\n\n animal_leg_count(animals)\n\n\nif __name__ == '__main__':\n main()\n# -\n\n# ## ISP\n\n# +\n#1-n\nfrom abc import ABCMeta, abstractmethod\nfrom six import with_metaclass\n\nDEFAULT_LION_LEG_COUNT = 4\nDEFAULT_MOUSE_LEG_COUNT = 4\nDEFAULT_SNAKE_LEG_COUNT = 0\n\n\nclass Animal(with_metaclass(ABCMeta)):\n\n @abstractmethod\n def get_legs_lion(self):\n raise NotImplementedError\n\n @abstractmethod\n def get_legs_mouse(self):\n raise NotImplementedError\n\n @abstractmethod\n def get_legs_snake(self):\n raise NotImplementedError\n\n\nclass Lion(Animal):\n\n def get_legs_lion(self):\n print(DEFAULT_LION_LEG_COUNT)\n\n def get_legs_mouse(self):\n print(DEFAULT_MOUSE_LEG_COUNT)\n\n def get_legs_snake(self):\n print(DEFAULT_SNAKE_LEG_COUNT)\n\n\nclass Mouse(Animal):\n\n def get_legs_lion(self):\n print(DEFAULT_LION_LEG_COUNT)\n\n def get_legs_mouse(self):\n print(DEFAULT_MOUSE_LEG_COUNT)\n\n def get_legs_snake(self):\n print(DEFAULT_SNAKE_LEG_COUNT)\n\n\nclass Snake(Animal):\n\n def get_legs_lion(self):\n print(DEFAULT_LION_LEG_COUNT)\n\n def get_legs_mouse(self):\n print(DEFAULT_MOUSE_LEG_COUNT)\n\n def get_legs_snake(self):\n print(DEFAULT_SNAKE_LEG_COUNT)\n\n\nclass Manager():\n\n def __init__(self):\n self.animal = None\n\n def set_animal(self, animal):\n assert isinstance(\n animal, Animal), \"`animal` must be of type {}\".format(Animal)\n\n self.animal = animal\n\n def get_legs_lion(self):\n self.animal.get_legs_lion()\n\n def get_legs_mouse(self):\n self.animal.get_legs_mouse()\n\n def get_legs_snake(self):\n self.animal.get_legs_snake()\n\n\ndef main():\n\n manager = Manager()\n manager.set_animal(Lion())\n manager.get_legs_lion()\n\n manager.set_animal(Mouse())\n manager.get_legs_mouse()\n\n manager.set_animal(Snake())\n manager.get_legs_snake()\n\n\nif __name__ == '__main__':\n main()\n\n# +\n#1.1-y\nfrom abc import ABCMeta, abstractmethod\nfrom six import with_metaclass\n\nDEFAULT_LION_LEG_COUNT = 4\nDEFAULT_MOUSE_LEG_COUNT = 4\nDEFAULT_SNAKE_LEG_COUNT = 0\n\nclass Animal(with_metaclass(ABCMeta)):\n\n @abstractmethod\n def get_legs_count(self):\n pass\n\n\nclass Manager():\n\n def __init__(self):\n self.animal = None\n\n def set_animal(self, animal):\n assert isinstance(\n animal, Animal), \"`animal` must be of type {}\".format(Animal)\n\n self.animal = animal\n\n def get_legs_count(self):\n self.animal.get_legs_count()\n\n\nclass Lion(Animal):\n\n def get_legs_count(self):\n print(DEFAULT_LION_LEG_COUNT)\n\n\nclass Mouse(Animal):\n\n def get_legs_count(self):\n print(DEFAULT_MOUSE_LEG_COUNT)\n\n\nclass Snake(Animal):\n\n def get_legs_count(self):\n print(DEFAULT_SNAKE_LEG_COUNT)\n\n\ndef main():\n\n manager = Manager()\n manager.set_animal(Lion())\n manager.get_legs_count()\n\n manager.set_animal(Mouse())\n manager.get_legs_count()\n\n manager.set_animal(Snake())\n manager.get_legs_count()\n\n\nif __name__ == '__main__':\n main()\n# -\n\n# ## DIP\n\n# +\n#1-n\nDEFAULT_LION_LEG_COUNT = 4\nDEFAULT_MOUSE_LEG_COUNT = 4\n\n\nclass Lion:\n\n def get_legs_count(self):\n print(DEFAULT_LION_LEG_COUNT)\n\n\nclass Mouse:\n\n def get_legs_count(self):\n print(DEFAULT_MOUSE_LEG_COUNT)\n\n\nclass Manager:\n\n def __init__(self):\n self.animal = None\n\n def set_animal(self, animal):\n assert isinstance(\n animal, Lion), \"`animal` must be of type {}\".format(Lion)\n\n self.animal = animal\n\n def get_legs_count(self):\n if self.animal is not None:\n self.animal.get_legs_count()\n\n\ndef main():\n\n lion = Lion()\n manager = Manager()\n manager.set_animal(lion)\n manager.get_legs_count()\n\n # не вовинно працювати...\n mouse = Mouse()\n try:\n manager.set_animal(mouse)\n except AssertionError:\n print(\"програма не підтримує мишу ...\")\n\n\nif __name__ == '__main__':\n main()\n\n# +\n#2.1-y\nfrom abc import ABCMeta, abstractmethod\nfrom six import with_metaclass\n\nDEFAULT_LION_LEG_COUNT = 4\nDEFAULT_MOUSE_LEG_COUNT = 4\nDEFAULT_SNAKE_LEG_COUNT = 0\n\n\nclass Animal(with_metaclass(ABCMeta)):\n\n @abstractmethod\n def get_legs_count(self):\n pass\n\n\nclass Lion(Animal):\n\n def get_legs_count(self):\n print(DEFAULT_LION_LEG_COUNT)\n\n\nclass Mouse(Animal):\n\n def get_legs_count(self):\n print(DEFAULT_MOUSE_LEG_COUNT)\n\n\nclass Snake(Animal):\n\n def get_legs_count(self):\n print(DEFAULT_SNAKE_LEG_COUNT)\n\n\nclass Manager:\n\n def __init__(self):\n self.animal = None\n\n def set_animal(self, animal):\n assert isinstance(\n animal, Animal), \"`animal` must be of type {}\".format(Animal)\n\n self.animal = animal\n\n def get_legs_count(self):\n if self.animal is not None:\n self.animal.get_legs_count()\n\n\ndef main():\n\n lion = Lion()\n manager = Manager()\n manager.set_animal(lion)\n manager.get_legs_count()\n\n # The following will work!\n mouse = Mouse()\n try:\n manager.set_animal(mouse)\n manager.get_legs_count()\n except AssertionError:\n print(\"програма не підтримує мишу ...\")\n\n snake = Snake()\n manager.set_animal(snake)\n manager.get_legs_count()\n\n\nif __name__ == '__main__':\n main()\n"},"script_size":{"kind":"number","value":15660,"string":"15,660"}}},{"rowIdx":98,"cells":{"path":{"kind":"string","value":"/modules/autoencoder_mednist.ipynb"},"content_id":{"kind":"string","value":"ce0013f8093546e25bb49f07f1d57586ac10cc86"},"detected_licenses":{"kind":"list like","value":["Apache-2.0"],"string":"[\n \"Apache-2.0\"\n]","isConversational":false},"license_type":{"kind":"string","value":"permissive"},"repo_name":{"kind":"string","value":"szh13818253048/tutorials"},"repo_url":{"kind":"string","value":"https://github.com/szh13818253048/tutorials"},"star_events_count":{"kind":"number","value":0,"string":"0"},"fork_events_count":{"kind":"number","value":0,"string":"0"},"gha_license_id":{"kind":"null"},"gha_event_created_at":{"kind":"null"},"gha_updated_at":{"kind":"null"},"gha_language":{"kind":"null"},"language":{"kind":"string","value":"Jupyter Notebook"},"is_generated":{"kind":"bool","value":false,"string":"false"},"is_vendor":{"kind":"bool","value":false,"string":"false"},"conversion_extension":{"kind":"string","value":".py"},"size":{"kind":"number","value":238335,"string":"238,335"},"script":{"kind":"string","value":"# ---\n# jupyter:\n# jupytext:\n# text_representation:\n# extension: .py\n# format_name: light\n# format_version: '1.5'\n# jupytext_version: 1.15.2\n# kernelspec:\n# display_name: Python 3\n# language: python\n# name: python3\n# ---\n\nimport numpy as np\nimport csv\nfrom extract import Extractor\n\nBASE = \"http://www.mapdevelopers.com/what-county-am-i-in.php?address=\"\n\nwith open(\"stations.csv\", 'r') as f:\n st = list(csv.reader(f, delimiter=','))\n\nheaders = st[0]\nstation_data = np.array(st[1:])\n\nids = {\n 'city': 'display_city',\n 'county': 'display_county',\n 'zipcode': 'display_zip',\n 'latitude': 'display_lat',\n 'longitude': 'display_lng'\n}\n\ne = Extractor()\nwith e:\n for row in station_data[:10]:\n station = row[2]\n url = BASE + station.replace(' ', '%20')\n e.get(url)\n idx = 3\n for key, value in ids.items():\n row[idx] = e.id_text(value)\n idx+=1\n\nwith open('stations_new.csv', 'wb') as f:\n h_string = \",\".join(headers)\n np.savetxt(f, station_data, fmt='%s,%s,%s,%s,%s,%s,%s,%s', delimiter=\",\",header=h_string,comments='')\n\n\ne.util import random_noise\n\nfrom monai.apps import download_and_extract\nfrom monai.config import print_config\nfrom monai.data import CacheDataset, DataLoader\nfrom monai.networks.nets import AutoEncoder\nfrom monai.transforms import (\n AddChannelD,\n Compose,\n LoadImageD,\n RandFlipD,\n RandRotateD,\n RandZoomD,\n ScaleIntensityD,\n EnsureTypeD,\n Lambda,\n)\nfrom monai.utils import set_determinism\n\nprint_config()\n# -\n\nlogging.basicConfig(stream=sys.stdout, level=logging.INFO)\nset_determinism(0)\ndevice = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n\n\n# Create small visualistaion function\ndef plot_ims(ims, shape=None, figsize=(10, 10), titles=None):\n shape = (1, len(ims)) if shape is None else shape\n plt.subplots(*shape, figsize=figsize)\n for i, im in enumerate(ims):\n plt.subplot(*shape, i + 1)\n im = plt.imread(im) if isinstance(im, str) else torch.squeeze(im)\n plt.imshow(im, cmap='gray')\n if titles is not None:\n plt.title(titles[i])\n plt.axis('off')\n plt.tight_layout()\n plt.show()\n\n\n# # 2. Get the data\n#\n# The MedNIST dataset was gathered from several sets from [TCIA](https://wiki.cancerimagingarchive.net/display/Public/Data+Usage+Policies+and+Restrictions),\n# [the RSNA Bone Age Challenge](http://rsnachallenges.cloudapp.net/competitions/4),\n# and [the NIH Chest X-ray dataset](https://cloud.google.com/healthcare/docs/resources/public-datasets/nih-chest).\n#\n# The dataset is kindly made available by [Dr. Bradley J. Erickson M.D., Ph.D.](https://www.mayo.edu/research/labs/radiology-informatics/overview) (Department of Radiology, Mayo Clinic)\n# under the Creative Commons [CC BY-SA 4.0 license](https://creativecommons.org/licenses/by-sa/4.0/).\n\ndirectory = os.environ.get(\"MONAI_DATA_DIRECTORY\")\nroot_dir = tempfile.mkdtemp() if directory is None else directory\nprint(root_dir)\n\n# +\nresource = \"https://drive.google.com/uc?id=1QsnnkvZyJPcbRoV_ArW8SnE1OTuoVbKE\"\nmd5 = \"0bc7306e7427e00ad1c5526a6677552d\"\n\ncompressed_file = os.path.join(root_dir, \"MedNIST.tar.gz\")\ndata_dir = os.path.join(root_dir, \"MedNIST\")\nif not os.path.exists(data_dir):\n download_and_extract(resource, compressed_file, root_dir, md5)\n\n# +\n# scan_type could be AbdomenCT BreastMRI CXR ChestCT Hand HeadCT\nscan_type = \"Hand\"\nim_dir = os.path.join(data_dir, scan_type)\nall_filenames = [os.path.join(im_dir, filename)\n for filename in os.listdir(im_dir)]\nrandom.shuffle(all_filenames)\n\n# Visualise a few of them\nrand_images = np.random.choice(all_filenames, 8, replace=False)\nplot_ims(rand_images, shape=(2, 4))\n# -\n\n# Split into training and testing\ntest_frac = 0.2\nnum_test = int(len(all_filenames) * test_frac)\nnum_train = len(all_filenames) - num_test\ntrain_datadict = [{\"im\": fname} for fname in all_filenames[:num_train]]\ntest_datadict = [{\"im\": fname} for fname in all_filenames[-num_test:]]\nprint(f\"total number of images: {len(all_filenames)}\")\nprint(f\"number of images for training: {len(train_datadict)}\")\nprint(f\"number of images for testing: {len(test_datadict)}\")\n\n# # 3. Create the image transform chain\n#\n# To train the autoencoder to de-blur/de-noise our images, we'll want to pass the degraded image into the encoder, but in the loss function, we'll do the comparison with the original, undegraded version. In this sense, the loss function will be minimised when the encode and decode steps manage to remove the degradation.\n#\n# Other than the fact that one version of the image is degraded and the other is not, we want them to be identical, meaning they need to be generated from the same transforms. The easiest way to do this is via dictionary transforms, where at the end, we have a lambda function that will return a dictionary containing the three images – the original, the Gaussian blurred and the noisy (salt and pepper).\n\n# +\nNoiseLambda = Lambda(lambda d: {\n \"orig\": d[\"im\"],\n \"gaus\": torch.tensor(\n random_noise(d[\"im\"], mode='gaussian'), dtype=torch.float32),\n \"s&p\": torch.tensor(random_noise(d[\"im\"], mode='s&p', salt_vs_pepper=0.1)),\n})\n\ntrain_transforms = Compose(\n [\n LoadImageD(keys=[\"im\"]),\n AddChannelD(keys=[\"im\"]),\n ScaleIntensityD(keys=[\"im\"]),\n RandRotateD(keys=[\"im\"], range_x=np.pi / 12, prob=0.5, keep_size=True),\n RandFlipD(keys=[\"im\"], spatial_axis=0, prob=0.5),\n RandZoomD(keys=[\"im\"], min_zoom=0.9, max_zoom=1.1, prob=0.5),\n EnsureTypeD(keys=[\"im\"]),\n NoiseLambda,\n ]\n)\n\ntest_transforms = Compose(\n [\n LoadImageD(keys=[\"im\"]),\n AddChannelD(keys=[\"im\"]),\n ScaleIntensityD(keys=[\"im\"]),\n EnsureTypeD(keys=[\"im\"]),\n NoiseLambda,\n ]\n)\n# -\n\n# ### Create dataset and dataloader\n#\n# Hold data and present batches during training.\n\n# +\nbatch_size = 300\nnum_workers = 10\n\ntrain_ds = CacheDataset(train_datadict, train_transforms,\n num_workers=num_workers)\ntrain_loader = DataLoader(train_ds, batch_size=batch_size,\n shuffle=True, num_workers=num_workers)\ntest_ds = CacheDataset(test_datadict, test_transforms, num_workers=num_workers)\ntest_loader = DataLoader(test_ds, batch_size=batch_size,\n shuffle=True, num_workers=num_workers)\n\n\n# -\n\n# Get image original and its degraded versions\ndef get_single_im(ds):\n loader = torch.utils.data.DataLoader(\n ds, batch_size=1, num_workers=10, shuffle=True)\n itera = iter(loader)\n return next(itera)\n\n\ndata = get_single_im(train_ds)\nplot_ims([data['orig'], data['gaus'], data['s&p']],\n titles=['orig', 'Gaussian', 's&p'])\n\n\ndef train(dict_key_for_training, max_epochs=10, learning_rate=1e-3):\n\n model = AutoEncoder(\n spatial_dims=2,\n in_channels=1,\n out_channels=1,\n channels=(4, 8, 16, 32),\n strides=(2, 2, 2, 2),\n ).to(device)\n\n # Create loss fn and optimiser\n loss_function = torch.nn.MSELoss()\n optimizer = torch.optim.Adam(model.parameters(), learning_rate)\n\n epoch_loss_values = []\n\n t = trange(\n max_epochs,\n desc=f\"{dict_key_for_training} -- epoch 0, avg loss: inf\", leave=True)\n for epoch in t:\n model.train()\n epoch_loss = 0\n step = 0\n for batch_data in train_loader:\n step += 1\n inputs = batch_data[dict_key_for_training].to(device)\n optimizer.zero_grad()\n outputs = model(inputs)\n loss = loss_function(outputs, batch_data['orig'].to(device))\n loss.backward()\n optimizer.step()\n epoch_loss += loss.item()\n epoch_loss /= step\n epoch_loss_values.append(epoch_loss)\n t.set_description(\n f\"{dict_key_for_training} -- epoch {epoch + 1}\"\n + f\", average loss: {epoch_loss:.4f}\")\n return model, epoch_loss_values\n\n\nmax_epochs = 50\ntraining_types = ['orig', 'gaus', 's&p']\nmodels = []\nepoch_losses = []\nfor training_type in training_types:\n model, epoch_loss = train(training_type, max_epochs=max_epochs)\n models.append(model)\n epoch_losses.append(epoch_loss)\n\nplt.figure()\nplt.title(\"Epoch Average Loss\")\nplt.xlabel(\"epoch\")\nfor y, label in zip(epoch_losses, training_types):\n x = list(range(1, len(y) + 1))\n line, = plt.plot(x, y)\n line.set_label(label)\nplt.legend()\n\n# +\ndata = get_single_im(test_ds)\n\nrecons = []\nfor model, training_type in zip(models, training_types):\n im = data[training_type]\n recon = model(im.to(device)).detach().cpu()\n recons.append(recon)\n\nplot_ims(\n [data['orig'], data['gaus'], data['s&p']] + recons,\n titles=['orig', 'Gaussian', 'S&P'] +\n [\"recon w/\\n\" + x for x in training_types],\n shape=(2, len(training_types)))\n# -\n\n# ### Cleanup data directory\n#\n# Remove directory if a temporary was used.\n\n# + pycharm={\"is_executing\": true}\nif directory is None:\n shutil.rmtree(root_dir)\n"},"script_size":{"kind":"number","value":9033,"string":"9,033"}}},{"rowIdx":99,"cells":{"path":{"kind":"string","value":"/.ipynb_checkpoints/DSherrill Map two excel worksheets using Python - Five Minute Python Automation Scripts-checkpoint.ipynb"},"content_id":{"kind":"string","value":"c35a9fa35bc67b7a86f2e46185430ad56a2e08c9"},"detected_licenses":{"kind":"list like","value":[],"string":"[]","isConversational":false},"license_type":{"kind":"string","value":"no_license"},"repo_name":{"kind":"string","value":"ulrikSebastienR/Python-Diaries"},"repo_url":{"kind":"string","value":"https://github.com/ulrikSebastienR/Python-Diaries"},"star_events_count":{"kind":"number","value":0,"string":"0"},"fork_events_count":{"kind":"number","value":0,"string":"0"},"gha_license_id":{"kind":"null"},"gha_event_created_at":{"kind":"null"},"gha_updated_at":{"kind":"null"},"gha_language":{"kind":"null"},"language":{"kind":"string","value":"Jupyter Notebook"},"is_generated":{"kind":"bool","value":false,"string":"false"},"is_vendor":{"kind":"bool","value":false,"string":"false"},"conversion_extension":{"kind":"string","value":".py"},"size":{"kind":"number","value":8898,"string":"8,898"},"script":{"kind":"string","value":"# ---\n# jupyter:\n# jupytext:\n# text_representation:\n# extension: .py\n# format_name: light\n# format_version: '1.5'\n# jupytext_version: 1.15.2\n# kernelspec:\n# display_name: Python 3\n# language: python\n# name: python3\n# ---\n\n# trying out https://www.youtube.com/watch?v=OB_ixIlQbWI&list=LLNzsZNOL8ahph4IIYK2c9Pg&index=4&t=0s \n# or Map two excel worksheets using Python - Five Minute Python Automation Scripts Derrick Sherrill\n\nimport pandas as pd\n\n# Assign a variable name to your excel file. Open Document Spreadsheets can't be opened. \n\nexcel1 = 'worksheet1.xlsx' \n\nprint(excel1)\n\n# #rows1 = rows(excel1)\n\n# #help(pd.Series.loc)\n\nexcel2 = 'worksheet2.xlsx'\n\nexcel2\n\npip install xlrd\n\n\ndf1 = pd.read_excel(excel1)\n\nprint(df1)\n\ndf2 = pd.read_excel(excel2)\nprint(df2)\n\nmerge = pd.merge(df1,df2,on = \"Date\")\nprint(merge)\n\nmerge.to_excel(\"output.xlsx\")\noutput_Sheet = \"output.xlsx\"\nprint(output_Sheet)\n\n\npip install openpyxl\n\ndf_Output = pd.read_excel(output_Sheet)\nprint(df_Output)\n\n\n"},"script_size":{"kind":"number","value":1024,"string":"1,024"}}}],"truncated":false,"partial":false},"paginationData":{"pageIndex":0,"numItemsPerPage":100,"numTotalItems":20000,"offset":0,"length":100}},"jwt":"eyJhbGciOiJFZERTQSJ9.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc3NjcxNzU0Nywic3ViIjoiL2RhdGFzZXRzL3JhbldhbmcvZGVkdXBfc21hbGwiLCJleHAiOjE3NzY3MjExNDcsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.rvmNTgkIPY33X6uoFBe-9fBdy5vBli56gUKiBChJkjffm2LZqM6EoSxlkfHsomzqllmheqP7rUmVOuvVx1VvDA","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"train","numRows":20000,"numBytesParquet":260285280}]},"discussionsStats":{"closed":0,"open":1,"total":1},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
path stringlengths 8 399 | content_id stringlengths 40 40 | detected_licenses list | license_type stringclasses 2
values | repo_name stringlengths 6 109 | repo_url stringlengths 25 128 | star_events_count int64 0 52.9k | fork_events_count int64 0 7.07k | gha_license_id stringclasses 9
values | gha_event_created_at timestamp[us] | gha_updated_at timestamp[us] | gha_language stringclasses 28
values | language stringclasses 1
value | is_generated bool 1
class | is_vendor bool 1
class | conversion_extension stringclasses 17
values | size int64 317 10.5M | script stringlengths 245 9.7M | script_size int64 245 9.7M |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
/robert_johnson_unit1_project.ipynb | f8e2e7d8c9d68f6a8996da501cd657dc2452b070 | [] | no_license | rejohnsonjr/General-Assembly-Projects | https://github.com/rejohnsonjr/General-Assembly-Projects | 0 | 0 | null | null | null | null | Jupyter Notebook | false | false | .py | 13,597 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# <img src="http://imgur.com/1ZcRyrc.png" style="float... | 9,345 |
/MLudemy/AdvancedSupervision.ipynb | ddd47391e8bd9340945eab8b4b971c369684ab0f | [] | no_license | phaneendhra-ch/Machine_Learning_ZTM | https://github.com/phaneendhra-ch/Machine_Learning_ZTM | 0 | 1 | null | null | null | null | Jupyter Notebook | false | false | .py | 90,392 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# name: python3
# ---
# + [markdown] id="XLXIojCUxnYp"
# # Qiskit Tutorialを触る
# Ref. -> [Tutorial](... | 8,736 |
/Feature Extraction/Audio_Feature_Extraction.ipynb | 6af56d9437db59ae8d7bdb614d8f293eab0c2f5d | [] | no_license | pushpanshu0501/Speech-Emotion-Recognition--1 | https://github.com/pushpanshu0501/Speech-Emotion-Recognition--1 | 3 | 5 | null | 2021-07-25T19:03:22 | 2021-07-23T08:58:51 | Jupyter Notebook | Jupyter Notebook | false | false | .py | 1,320,163 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# # Pipeline
#
# Data ... | 9,604 |
/week3/week3_task2_fine_tuning_clean.ipynb | 86c258591c0e5601cec01d6ba348f1c1eac13fac | [] | no_license | DieMyst/intro-to-dl | https://github.com/DieMyst/intro-to-dl | 0 | 0 | null | null | null | null | Jupyter Notebook | false | false | .py | 19,162 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# <div class="alert alert-block alert-info" style="mar... | 9,596 |
/0. Preparations/0. Preparations.ipynb | 3e6796b1a6f13da5cc5aa5d787113e098da4de56 | [] | no_license | mrayy/PracticalML | https://github.com/mrayy/PracticalML | 5 | 2 | null | null | null | null | Jupyter Notebook | false | false | .py | 4,151 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# # Session 0: PML Tools Overview
#
# This manual cont... | 3,484 |
/05_Pandas_on_my_own/.ipynb_checkpoints/01_Pandas_Introducing_The_Dataset-checkpoint.ipynb | f6a81257205b74160c8efec3bcba6ba6868f26a6 | [] | no_license | emunozlorenzo/MasterDataScience | https://github.com/emunozlorenzo/MasterDataScience | 3 | 2 | null | null | null | null | Jupyter Notebook | false | false | .py | 16,753 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# # Pandas For Data Science: Introducing The Datasets
... | 1,398 |
/Array practice 1.ipynb | fde065553d26c9ac25e0d369e5e641f88ff34a09 | [] | no_license | Manish-Kumar-9782/Data-Structures-in-python | https://github.com/Manish-Kumar-9782/Data-Structures-in-python | 0 | 0 | null | null | null | null | Jupyter Notebook | false | false | .py | 9,998 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
list_of_words = ["Hello", "there.", "How", "are", "you... | 432 |
/devel_notebooks/igraph_test_GN_and_N_fast.ipynb | 82f3f2323eaf1ca3a38134e5d7505c34d693386a | [] | no_license | riblidezso/graph_clust_alg_comparison | https://github.com/riblidezso/graph_clust_alg_comparison | 0 | 0 | null | null | null | null | Jupyter Notebook | false | false | .py | 48,529 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# **[Machine Learning Course Home Page](https://www.ka... | 3,178 |
/PythonML_Practice.ipynb | 5921c345e28f3b0ee97af843e3fae1a4b5bfeb6d | [] | no_license | vijendranp/Python--Computational-Approach | https://github.com/vijendranp/Python--Computational-Approach | 0 | 0 | null | null | null | null | Jupyter Notebook | false | false | .py | 974 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# name: python3
# ---
# + [markdown] id="view-in-github" colab_type="text"
# <a href="https://colab... | 570 |
/src/Henry/Gmail Analysis/Chi-squared, time prediction and linear regression/.ipynb_checkpoints/SARIMA-checkpoint.ipynb | 7532c60ce2c7250301dcd12b70028c32daa936dd | [] | no_license | UNCG-CSE/G_Suite_Metrics | https://github.com/UNCG-CSE/G_Suite_Metrics | 0 | 4 | null | 2019-12-12T21:47:23 | 2019-12-12T21:16:54 | Jupyter Notebook | Jupyter Notebook | false | false | .py | 2,673,838 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# ## Played with SARIMA, pmdarima, and fb prophet libr... | 5,260 |
/dashboard.ipynb | 1e7374e7b23ef2d6c8314b800850b88d6ce446cf | [] | no_license | kielwheat/SF_realestate_analysis_PyViz | https://github.com/kielwheat/SF_realestate_analysis_PyViz | 0 | 0 | null | null | null | null | Jupyter Notebook | false | false | .py | 6,219,403 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# Can I make one page-sized plot that contains all the... | 3,586 |
/Open CV Information.ipynb | d5c83ddd5bc6529f34f7acb09811e7c34faf1159 | [] | no_license | RoodraKanwar/OpenCV | https://github.com/RoodraKanwar/OpenCV | 0 | 0 | null | null | null | null | Jupyter Notebook | false | false | .py | 23,310 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
import cv2
#
# # READS IMAGE
# +
img = cv2.imread('p... | 13,030 |
/Notebooks/EnisBerk/TransferLearningVggish.ipynb | acc646e571d5dff9cf5538d299cf250f291ad9f8 | [] | no_license | Yunhua468/Audio-Visual-Emotion-and-Sentiment-Research | https://github.com/Yunhua468/Audio-Visual-Emotion-and-Sentiment-Research | 3 | 0 | null | null | null | null | Jupyter Notebook | false | false | .py | 7,524 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# name: python3
# ---
# + id="DYd3hHcU3HZw" colab_type="code" colab={}
# !wget https://zenodo.org/a... | 3,834 |
/hw_webinar_1.ipynb | e44b0dfea3baf7d93085610edfe9f2b67b586889 | [] | no_license | olhaexe/RecSys | https://github.com/olhaexe/RecSys | 0 | 0 | null | null | null | null | Jupyter Notebook | false | false | .py | 5,785 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# # Домашнее задание - 1
# Заполните пропуски #your_c... | 2,719 |
/Aula7_Analise_Exploratoria.ipynb | 68d7293545fa546ad5103df4517b5d14a776e1e0 | [] | no_license | clerisson-san/Analise_de_dados_com_Python_e_Pandas_by_DIO | https://github.com/clerisson-san/Analise_de_dados_com_Python_e_Pandas_by_DIO | 0 | 0 | null | null | null | null | Jupyter Notebook | false | false | .py | 162,232 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# name: python3
# ---
# + [markdown] id="view-in-github" colab_type="text"
# <a href="https://colab... | 7,761 |
/start.ipynb | dbda13c6603f1d4b3e763c30dd573484cacb869c | [] | no_license | BetterWill/Test_01 | https://github.com/BetterWill/Test_01 | 0 | 0 | null | null | null | null | Jupyter Notebook | false | false | .py | 55,641 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# + active=""
# select aa.asset_seriesName_showTitle_c... | 3,568 |
/Playground/MNIST_random_classification.ipynb | f79331bfc086d4d892fcd10f7b43f0722b226f43 | [] | no_license | Black3rror/AI | https://github.com/Black3rror/AI | 0 | 0 | null | null | null | null | Jupyter Notebook | false | false | .py | 39,465 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# + [markdown] colab_type="text" id="view-in-github"
#... | 30,013 |
/book_code/ch4.ipynb | 8ba4ffaa971fb0eb650776233f15dc0614a5c6b6 | [] | no_license | jackmoody11/statistical-rethinking | https://github.com/jackmoody11/statistical-rethinking | 0 | 0 | null | null | null | null | Jupyter Notebook | false | false | .py | 197,676 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: 'Python 3.7.3 64-bit (''venv'': venv)'
# name: python_defaultSpec_1597955304258
# ---
# +
# Book Code 4.5
im... | 2,203 |
/chapter3/ch3.ipynb | d3e2500390fdacd6b72768475141899c6ac631ad | [] | no_license | h-asano/nlp100knock | https://github.com/h-asano/nlp100knock | 1 | 0 | null | 2017-01-29T06:35:14 | 2017-01-29T06:28:02 | null | Jupyter Notebook | false | false | .py | 33,645 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python [default]
# language: python
# name: python3
# ---
# # 第3章: 正規表現
# ---
# Wikipediaの記事を以下のフォーマットで書... | 9,592 |
/08-homework/03 - School Board Minutes.ipynb | cb165838eea25989f82ff5a76d288a89a45a848b | [] | no_license | AmyOKruk/foundations_homework | https://github.com/AmyOKruk/foundations_homework | 0 | 0 | null | null | null | null | Jupyter Notebook | false | false | .py | 12,518 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# # School Board Minutes
#
# Scrape all of the school ... | 2,195 |
/Old_Photo_restore.ipynb | 8a8f6b411b45c27ec28e54b893b786c372072c6d | [
"Apache-2.0"
] | permissive | abheeshtroy/old-photo-restore-simplified | https://github.com/abheeshtroy/old-photo-restore-simplified | 0 | 0 | null | null | null | null | Jupyter Notebook | false | false | .py | 578,068 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# name: python3
# ---
# + [markdown] id="view-in-github" colab_type="text"
# <a href="https://colab... | 11,606 |
/Learn_Python/Udemy_Curso_Basico/dev_09_zejercicio_01.ipynb | bf3c23c377fb665d9fdb126e6766930fd1188656 | [] | no_license | apizarroe/Personal_Code | https://github.com/apizarroe/Personal_Code | 0 | 1 | null | null | null | null | Jupyter Notebook | false | false | .py | 1,132 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# ---
# +
##################Ejercicio
#Crear un modulo "modulo1.py"
#Añadir la clase "Coche" creada en un ejercicio anterior al "modulo1"
#Añadir la... | 2,868 |
/Ekstraksi Fitur 2/.ipynb_checkpoints/Extraction Feature WIth Morphological-checkpoint.ipynb | 65eb3dc46aaa1d095b0ee10e67ab827b63e2a6c9 | [] | no_license | ragilhadi/pkl-textdetection-bpnn | https://github.com/ragilhadi/pkl-textdetection-bpnn | 0 | 0 | null | null | null | null | Jupyter Notebook | false | false | .py | 1,528,443 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
import numpy as np
import cv2 as cv
import matplotlib.... | 5,751 |
/homework/Day_002_HW.ipynb | ce66bd7d434cadb246b5a9f30c04ddc7a3dea89a | [] | no_license | wtchenzf/2nd-ML100Days | https://github.com/wtchenzf/2nd-ML100Days | 0 | 0 | null | null | null | null | Jupyter Notebook | false | false | .py | 7,894 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# ## 練習時間
# 資料的操作有很多，接下來的馬拉松中我們會介紹常被使用到的操作，參加者不妨先自行想像一... | 1,010 |
/code/jl-files/STARAS-master/Networks/Sensibility_NetDensity/runs/20171112_215319_Sim_Watts_Density/Hex_Stack.ipynb | 5a0f640f52b50df14f7528c8211131c18ccdfdbf | [] | no_license | ccg-esb/MSW3D | https://github.com/ccg-esb/MSW3D | 0 | 0 | null | null | null | null | Jupyter Notebook | false | false | .py | 434,745 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# ## Hexbin and Stack Plotter
CC = 0.2
# We call the... | 10,955 |
/Exercises/Римски Императори.ipynb | 4dc090a2f61da660e9a3593e8e5b334c12624bff | [] | no_license | ironsmile/machine-learning-fmi | https://github.com/ironsmile/machine-learning-fmi | 1 | 0 | null | null | null | null | Jupyter Notebook | false | false | .py | 208,462 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# # Римски императори
#
# Тук ще се опитам да предскаж... | 28,459 |
/assignments/01_Intro2images-stVer.ipynb | 4c19b92543a0a199321351440743bd0c5a184586 | [] | no_license | iknyazeva/ML2020 | https://github.com/iknyazeva/ML2020 | 0 | 13 | null | 2020-09-21T09:56:38 | 2020-09-21T09:53:56 | Jupyter Notebook | Jupyter Notebook | false | false | .py | 10,090,911 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# + Collapsed="false"
import numpy as np
from skimage ... | 7,627 |
/Data PreProcessing - DSN Staff Promotions 2019.ipynb | 68897ba4eea59265cab6d228eaa882f37f0e9e49 | [] | no_license | rawnc/Data-PreProcessing---Using-DSN-Staff-Promotions-2019-Data | https://github.com/rawnc/Data-PreProcessing---Using-DSN-Staff-Promotions-2019-Data | 0 | 0 | null | null | null | null | Jupyter Notebook | false | false | .py | 1,630,048 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# +
# include modules
from os import listdir
from os.p... | 1,339 |
/notebooks/sample_lakes.ipynb | 493ea7a7094217285b6aa12c3eef5786b614aada | [
"BSD-3-Clause"
] | permissive | Ciaran1981/morph-snakes | https://github.com/Ciaran1981/morph-snakes | 0 | 0 | null | 2020-04-29T11:39:05 | 2020-04-29T11:05:26 | null | Jupyter Notebook | false | false | .py | 652,492 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# + [markdown] colab_type="text" id="S0WvPSo3MqKp"
# #... | 35,263 |
/statistics/Untitled.ipynb | fbd072d8db8ed891d21634998cd1399164ca8d37 | [
"MIT"
] | permissive | priyaananthasankar/learning | https://github.com/priyaananthasankar/learning | 0 | 0 | null | 2019-06-25T01:06:19 | 2019-06-03T16:36:41 | null | Jupyter Notebook | false | false | .py | 3,996 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# # Traffic Light Classifier
# ---
#
# In this project... | 26,815 |
/SpinAxis.ipynb | 75df59a39fc25d3da8379066c1555e699dcc8e17 | [] | no_license | chrisjackson4256/BaseballDataAnalyses | https://github.com/chrisjackson4256/BaseballDataAnalyses | 0 | 0 | null | null | null | null | Jupyter Notebook | false | false | .py | 99,200 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# # Calculating the Spin Axis of a Pitch
#
# This trie... | 8,125 |
/analysis/scripts/milestone3processed.ipynb | 844343251c4e685abec7f57334087a2479b1cfcd | [
"MIT"
] | permissive | data301-2020-winter1/course-project-solo_303 | https://github.com/data301-2020-winter1/course-project-solo_303 | 0 | 0 | null | null | null | null | Jupyter Notebook | false | false | .py | 12,589 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 2
# language: python
# name: python2
# ---
# # Functions
#
#
# `Function` class objects provide t... | 25,979 |
/C5 Sequence Models/5-Emojify_v2a.ipynb | 84a2f8387a4aaa6564ebd16ec9bfb2f5be832d84 | [] | no_license | databoy-eng/Deep-Learning-Specialization | https://github.com/databoy-eng/Deep-Learning-Specialization | 0 | 0 | null | null | null | null | Jupyter Notebook | false | false | .py | 77,624 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# # Emojify!
#
# Welcome to the second assignment of ... | 39,775 |
/45 实现混淆矩阵，精准率和召回率.ipynb | effcd6c0c7bf45342ed911216fe2241f2606f654 | [] | no_license | BaiYuhaoSpiceeYJ/MachineLearning | https://github.com/BaiYuhaoSpiceeYJ/MachineLearning | 0 | 0 | null | null | null | null | Jupyter Notebook | false | false | .py | 4,043 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# +
import numpy as np
from sklearn import datasets
d... | 2,397 |
/investigate-tmdb-dataset.ipynb | 13cf6d106cfbed8f8be3fd879f81e50f09ceb433 | [
"MIT"
] | permissive | bassamfaramawi/Investigate-TMDb-Movie-Dataset | https://github.com/bassamfaramawi/Investigate-TMDb-Movie-Dataset | 0 | 0 | null | null | null | null | Jupyter Notebook | false | false | .py | 551,109 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# <a href="https://www.kaggle.com/code/tiodaronzi3/inv... | 23,434 |
/08_File_Processing.ipynb | 6ce8f1f8eea793803e684807d8005748047fccb3 | [] | no_license | pvnmahathi/fmml2021 | https://github.com/pvnmahathi/fmml2021 | 2 | 0 | null | 2021-09-03T12:16:40 | 2021-08-31T06:22:59 | null | Jupyter Notebook | false | false | .py | 9,467 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# name: python3
# ---
# + [markdown] id="view-in-github" colab_type="text"
# <a href="https://colab... | 2,373 |
/ml-mipt/week0_02_linear_reg/week02_linear_regression.ipynb | 02152d0ec6588e261ec7bbee52cc5e4d8a7b2fca | [
"MIT"
] | permissive | ShamsimukhametovDanil/ml-mipt | https://github.com/ShamsimukhametovDanil/ml-mipt | 0 | 0 | null | null | null | null | Jupyter Notebook | false | false | .py | 696,966 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# ## ml-mipt course
#
# ### Seminar 2
# ### Linear Reg... | 20,019 |
/LogReg, SVM & Model(Bin) - SampleSize vs Score.ipynb | c454f4d531378584e633686d47737ad29940eb2d | [] | no_license | Ilanagweinstein/CodeBlue | https://github.com/Ilanagweinstein/CodeBlue | 1 | 0 | null | 2020-01-02T18:36:02 | 2019-12-08T21:38:58 | null | Jupyter Notebook | false | false | .py | 73,775 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
import os
import numpy as np
import pandas as pd
impor... | 15,222 |
/DNN.ipynb | 224d1ec998e67d6254d4825ae22ebad2f6cb0692 | [] | no_license | GiuliaLanzillotta/TensorflowEssentials | https://github.com/GiuliaLanzillotta/TensorflowEssentials | 0 | 0 | null | null | null | null | Jupyter Notebook | false | false | .py | 5,323,755 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# name: python3
# ---
# + [markdown] id="view-in-github" colab_type="text"
# <a href="https://colab... | 5,302,939 |
/HydrologyOfWorldCities.ipynb | fc80c27c3ff04fda77e2e2d1e0a164d41c6e2378 | [] | no_license | amireson/HydrologyOfWorldCities | https://github.com/amireson/HydrologyOfWorldCities | 0 | 0 | null | null | null | null | Jupyter Notebook | false | false | .py | 311,826 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3 (ipykernel)
# language: python
# name: python3
# ---
# # Hydrology of World Cities
#
# By Andre... | 1,177 |
/Air_AQI.ipynb | d65d7a2d58b8237dc9696bc76e3883338af65c0b | [] | no_license | DonadriHema/Air-quality-prediction | https://github.com/DonadriHema/Air-quality-prediction | 0 | 0 | null | null | null | null | Jupyter Notebook | false | false | .py | 579,522 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
import numpy as np
import pandas as pd
import matplotl... | 8,488 |
/acceleration/plot_global.ipynb | 9267162a590fe161b2be56cc212361b7f30ebb72 | [] | no_license | erwinlambert/codependence | https://github.com/erwinlambert/codependence | 0 | 0 | null | null | null | null | Jupyter Notebook | false | false | .py | 409,832 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# # ToDo
#
# Next week: OpenCV, CNN, doc, M5 day; HOML... | 26,333 |
/Example_Notebooks/.ipynb_checkpoints/Readme-checkpoint.ipynb | f8249ed89971362ba25a65daea90c4ad81460d6f | [
"BSD-3-Clause-LBNL"
] | permissive | zhuhapeng/a3dbr | https://github.com/zhuhapeng/a3dbr | 0 | 0 | null | null | null | null | Jupyter Notebook | false | false | .py | 868 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: a3dbr
# language: python
# name: a3dbr
# ---
# ### notebooks with _ST are modified version of Marc's not... | 492 |
/Initialization.ipynb | 77b19a3f557f7e678a42cf459aacb35c8a3d603f | [] | no_license | Dilavarj7/Improving-Deep-Neural-Networks | https://github.com/Dilavarj7/Improving-Deep-Neural-Networks | 2 | 0 | null | null | null | null | Jupyter Notebook | false | false | .py | 279,184 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# + [markdown] id="view-in-github" colab_type="text"
#... | 20,499 |
/Guigma-Thierry-Final_project-Part3.ipynb | 99f17dab30a6003f7dbb4d2cf866df4f3aeb5b6c | [] | no_license | tguigma/DataViz_Final-Project | https://github.com/tguigma/DataViz_Final-Project | 0 | 0 | null | null | null | null | Jupyter Notebook | false | false | .py | 421,348 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# +
import numpy as np
import networkx as nx
from netw... | 5,997 |
/notebook.ipynb | 2a3698b892a0bc314b70ce88beab29bfbec99d55 | [] | no_license | blakeruwali/A-Network-Analysis-of-Game-of-Thrones | https://github.com/blakeruwali/A-Network-Analysis-of-Game-of-Thrones | 0 | 0 | null | null | null | null | Jupyter Notebook | false | false | .py | 240,415 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# + tags=["context"] run_control={"frozen": true} edit... | 11,022 |
/yysage/30-10-2h33-nerds-midi-savart.ipynb | 800f14b4ac0ce61a4297b58add573cdfdd242f84 | [] | no_license | ictus5d/doc | https://github.com/ictus5d/doc | 0 | 0 | null | null | null | null | Jupyter Notebook | false | false | .py | 106,521 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
from pyscf import scf,gto
import numpy as np
import in... | 11,791 |
/Módulo_2_Exercício_10_ITEM_2.ipynb | d60f73a513ad150e25b2f65b7da55b90880cab3c | [] | no_license | jessikamorais/Metodos_Numericos | https://github.com/jessikamorais/Metodos_Numericos | 0 | 0 | null | null | null | null | Jupyter Notebook | false | false | .py | 87,870 | import openpiv.tools
import openpiv.process
import openpiv.preprocess
import openpiv.validation
import openpiv.filters
import openpiv.scaling
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.cm as cm
# %matplotlib inline
# import pandas as pd
import os
# import cv2s
# from scipy import ndimage
wi... | 37,111 |
/Recommendation_Sytems_with_Python/Pydata_recommendation_systems_anushree.ipynb | f624a2dfd74a076dc43c7651ffcb273823676be1 | [] | no_license | anushreesrinivas/Data-Science | https://github.com/anushreesrinivas/Data-Science | 0 | 1 | null | null | null | null | Jupyter Notebook | false | false | .py | 37,878 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# +
import copy
import time
import pickle
from collect... | 14,180 |
/Task 5 Data Science & Business Analytics Internship at The Sparks Foundation.ipynb | 058a8a89f1383f0c5227fccd0ee1f406291c771a | [] | no_license | VijayChawla12/Data-Science-Business-Analytics-Internship-at-The-Sparks-Foundation | https://github.com/VijayChawla12/Data-Science-Business-Analytics-Internship-at-The-Sparks-Foundation | 1 | 0 | null | 2021-01-09T18:18:00 | 2021-01-09T18:12:50 | Jupyter Notebook | Jupyter Notebook | false | false | .py | 296,073 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# # The Sparks Foundation - Data Science & Business An... | 7,090 |
/homework_9/hw_titanic.ipynb | 379d03d70b554af0018b89f7e5e346b1acdda3cc | [] | no_license | eszakharova/prog_4year | https://github.com/eszakharova/prog_4year | 0 | 0 | null | null | null | null | Jupyter Notebook | false | false | .py | 94,226 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# +
import time, re
from selenium import webdriver
fro... | 2,248 |
/Projeto_AED_DanielVictor.ipynb | db6f873dc096ce6b719fb0930535619288ff3d2d | [] | no_license | danivict/Estatistica-Aplicada-a-Computacao | https://github.com/danivict/Estatistica-Aplicada-a-Computacao | 0 | 0 | null | null | null | null | Jupyter Notebook | false | false | .py | 832,348 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# # Projeto_AED
# Importação das bibliotecas necessár... | 32,163 |
/experiments/2. archattribute/text_correlation.ipynb | f0e8c8489df8b0fbf0b39657af012b90d313de77 | [] | no_license | vdefont/archipelago | https://github.com/vdefont/archipelago | 0 | 0 | null | 2021-04-03T23:31:44 | 2021-04-03T03:39:43 | null | Jupyter Notebook | false | false | .py | 16,817 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# name: python3
# ---
# + [markdown] id="view-in-github" colab_type="text"
# <a href="https://colab... | 32,318 |
/P2.ipynb | 2ef5eca96a00a634bad8e086f32bde3e2c2b2319 | [] | no_license | Ludvins/Practicas_GD | https://github.com/Ludvins/Practicas_GD | 0 | 0 | null | null | null | null | Jupyter Notebook | false | false | .py | 30,903 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# <html>
# <table width="100%" cellspacing="2" cellpad... | 9,436 |
/day7_reading_journal.ipynb | 1b4f90e8d1a5b39d23cef609614b47a086fcfd06 | [] | no_license | SungwooPark/ReadingJournal | https://github.com/SungwooPark/ReadingJournal | 0 | 0 | null | 2016-01-24T20:21:01 | 2016-01-21T03:15:26 | null | Jupyter Notebook | false | false | .py | 17,400 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 2
# language: python
# name: python2
# ---
# # Day 7 Reading Journal
#
# This journal includes se... | 12,929 |
/Object Detection (reduced errors).ipynb | 9f819813b30e5dbf3674c09d9b69150e2b2b7b2a | [] | no_license | raksup/ObjectDetection | https://github.com/raksup/ObjectDetection | 0 | 0 | null | null | null | null | Jupyter Notebook | false | false | .py | 152,829 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# # Recommender Systems 2020/21
#
#
# ## Practice 4 - ... | 21,073 |
/Lectures/13_2_Bootstrap.ipynb | eea9c034c710596178110576de946292f9b3d85b | [] | no_license | bonchae/DataScience | https://github.com/bonchae/DataScience | 0 | 0 | null | null | null | null | Jupyter Notebook | false | false | .py | 204,058 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# name: python3
# ---
# + id="I9ZygAHeJKeS" colab_type="code" colab={"base_uri": "https://localhost... | 16,209 |
/homework/Day75-Back_Propagation_HW.ipynb | 29c7338b9186d6142a4eea5aa885a2e3888b60fa | [] | no_license | fangggggg87/2nd-ML100Days | https://github.com/fangggggg87/2nd-ML100Days | 0 | 0 | null | null | null | null | Jupyter Notebook | false | false | .py | 17,605 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# # 作業目標:
#
# 通過建立多層的神經網路, 了解權值矩陣更新
# # 作業重點:
#
... | 2,038 |
/PYTHON/Notebooks/.ipynb_checkpoints/GeoH5-checkpoint.ipynb | 9d1993be58726fd36c7e5a54163cecbfd474079c | [] | no_license | fourndo/ScriptsBank | https://github.com/fourndo/ScriptsBank | 3 | 2 | null | null | null | null | Jupyter Notebook | false | false | .py | 9,843 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
import h5py
import numpy as np
import ipywidgets as wi... | 1,819 |
/notebooks/make_analysis.ipynb | 59245cd7c7cb7e8463745d0a02bc5d42359870cf | [] | no_license | brhillman/e3smplot | https://github.com/brhillman/e3smplot | 1 | 2 | null | 2023-01-11T21:00:10 | 2021-11-18T18:01:46 | Jupyter Notebook | Jupyter Notebook | false | false | .py | 225,774 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: e3smplot
# language: python
# name: e3smplot
# ---
# %matplotlib inline
# %load_ext autoreload
# %autore... | 28,968 |
/examples/Demand_Side_Management/DSMtesting.ipynb | c08848dfd52b784513f215e8707f617c8d1b8e8a | [
"MIT"
] | permissive | passion4energy/FINE | https://github.com/passion4energy/FINE | 0 | 0 | null | null | null | null | Jupyter Notebook | false | false | .py | 255,331 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# # DSM (BETA Phase!)
import functions
import FINE as... | 1,310 |
/Source_code/Day2/Day2.ipynb | 52e6697f44530caf332694bfbc1a44634a29069a | [] | no_license | jaewookie/datalearning | https://github.com/jaewookie/datalearning | 0 | 0 | null | null | null | null | Jupyter Notebook | false | false | .py | 133,608 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# ## MNIST 맛보기
# - 손글씨 숫자 인식
import sys, os
sys.path.... | 13,705 |
/ETL_function_test.ipynb | 06672075ebd0b3d853f5d614afbca1a6373225c3 | [] | no_license | donovancai/Movies-ETL | https://github.com/donovancai/Movies-ETL | 0 | 0 | null | null | null | null | Jupyter Notebook | false | false | .py | 26,133 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: PythonData
# language: python
# name: pythondata
# ---
# +
import json
import pandas as pd
import numpy ... | 2,932 |
/.ipynb_checkpoints/cavcalc1000nvt-checkpoint.ipynb | 7c427e74e2f1db00ef0d92ff858a5a98ede4fc26 | [] | no_license | AHTARazzak/machine_learning_scripts | https://github.com/AHTARazzak/machine_learning_scripts | 0 | 0 | null | null | null | null | Jupyter Notebook | false | false | .py | 250,961 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python
# language: python
# name: conda-env-python-py
# ---
# <a href="https://cognitiveclass.ai/">
# ... | 7,177 |
/notebooks/k_nearest_neighbors.ipynb | 1292b0e339a63c9ed5c590cb8992e4c7bada74cb | [] | no_license | jbrownuf07/datasciencelearnings | https://github.com/jbrownuf07/datasciencelearnings | 0 | 0 | null | null | null | null | Jupyter Notebook | false | false | .py | 1,450 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# # K-Nearest Neighbors
#
#
# [Reference](https://mach... | 2,595 |
/notebooks/API/twitch_api_calls.ipynb | f4bf18e835b483aebe235b31649d7e86ca61dfbf | [] | no_license | katerinadek/StarFish | https://github.com/katerinadek/StarFish | 0 | 0 | null | null | null | null | Jupyter Notebook | false | false | .py | 3,854 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# +
import requests
from twitchAPI.twitch import Twitc... | 2,075 |
/Week4_31052021/Day2/rolling_statistics.ipynb | d2a4a752f787feafc1badee11bfdf8ff81e6e1ab | [] | no_license | AbigalChulchill/MyFinTechHomework | https://github.com/AbigalChulchill/MyFinTechHomework | 0 | 0 | null | null | null | null | Jupyter Notebook | false | false | .py | 225,072 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
import pandas as pd
import numpy as np
import seaborn ... | 35,395 |
/experiment_4.ipynb | 666e4740c6509fda3b6642902bc89e9db7827b29 | [] | no_license | FilatovArtm/Images2Life | https://github.com/FilatovArtm/Images2Life | 0 | 0 | null | null | null | null | Jupyter Notebook | false | false | .py | 248,518 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# # Train with video
# +
from utils.common_utils impo... | 3,369 |
/Python OOPs/.ipynb_checkpoints/Classes and Objects-checkpoint.ipynb | bad9b23210de0c720612e35e3a28eef83a53fd98 | [] | no_license | KushYadav/Machine-Learning | https://github.com/KushYadav/Machine-Learning | 0 | 0 | null | null | null | null | Jupyter Notebook | false | false | .py | 7,430 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# ### Classes and Objects
class Car:
pass
print... | 3,570 |
/in_paper/shrinkage_prior/GZZ_sensitivity/synthetic_data_swrate-5.ipynb | bcd15769125282dd95aedc4b7484aaafcf9f41e4 | [] | no_license | deborsheesen/G-ZZ | https://github.com/deborsheesen/G-ZZ | 0 | 1 | null | null | null | null | Jupyter Notebook | false | false | .jl | 2,570 | # -*- coding: utf-8 -*-
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .jl
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Julia 0.6.4
# language: julia
# name: julia-0.6
# ---
using Distributions, TimeI... | 1,072 |
/tutorials/single_table_data/04_TVAE_Model.ipynb | b0dbbf3eed08df309350f081677b7faad90be77e | [
"MIT"
] | permissive | sarahmish/SDV | https://github.com/sarahmish/SDV | 1 | 0 | MIT | 2021-06-28T12:49:26 | 2021-06-26T16:24:30 | null | Jupyter Notebook | false | false | .py | 101,682 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# name: python3
# ---
# + id="T_FGs7reLrEC" colab={"base_uri": "https://localhost:8080/"} outputId=... | 8,474 |
/project_week3_2.ipynb | eaaf2ea151acdb25edb85e770d5432c3086f2703 | [] | no_license | patrickCid/Coursera_Capstone | https://github.com/patrickCid/Coursera_Capstone | 0 | 0 | null | null | null | null | Jupyter Notebook | false | false | .py | 35,906 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# # Load/Merge raw data to prepare for Clustering
imp... | 787 |
/Practical_statistics/Confidence_intervals/Confidence Intervals - Part I.ipynb | 98389b9591cf9f1c4c8b6061608391316d21b123 | [
"Apache-2.0"
] | permissive | sudoberlin/Data_Analyst_ND | https://github.com/sudoberlin/Data_Analyst_ND | 4 | 0 | null | null | null | null | Jupyter Notebook | false | false | .py | 18,056 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# ### Confidence Intervals - Part I
#
# First let's re... | 8,980 |
/Assignment 1 AND_OR gate_using_Perceptron.ipynb | 3cc112b2548bfe1127fe64fb8e6f00d5c5a1dc24 | [] | no_license | Ashish438/Deep_Learning_Assignments | https://github.com/Ashish438/Deep_Learning_Assignments | 2 | 0 | null | null | null | null | Jupyter Notebook | false | false | .py | 34,675 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# HIDDEN
from datascience import *
# %matplotlib inlin... | 5,306,892 |
/Machine learning with python and R.ipynb | 209abcea9d2457b5a9461c232995b4f69b4e28ad | [] | no_license | v-alan-m/machine_learning_python_and_R | https://github.com/v-alan-m/machine_learning_python_and_R | 0 | 0 | null | null | null | null | Jupyter Notebook | false | false | .py | 5,096 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# # Machine learning with python and R
# Install:
# -... | 3,725 |
/Week7/week_7.ipynb | fd1381d66161c56d24283f370a1f94f35200ba10 | [] | no_license | Devsaa05/Inter_2-incubitu | https://github.com/Devsaa05/Inter_2-incubitu | 1 | 0 | null | 2020-07-31T12:32:59 | 2020-07-31T12:32:44 | Jupyter Notebook | Jupyter Notebook | false | false | .py | 117,856 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
#https://rightcode.co.jp/blog/information-technology/p... | 39,451 |
/python/deeplearning/sonar_data_analysis.ipynb | ba9481f11fbf685b6aeaebb3308ba58b05b55752 | [] | no_license | KANGSUNGHO/StudySpace | https://github.com/KANGSUNGHO/StudySpace | 0 | 0 | null | null | null | null | Jupyter Notebook | false | false | .py | 33,916 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
import math
def primeFact(n):
while(n % 2 == 0):... | 25,263 |
/notebooks/.ipynb_checkpoints/02_practice_exercises-checkpoint.ipynb | 4a64c4c84754ced3728015437cd7f50594775aa2 | [] | no_license | pcthink11/dw17 | https://github.com/pcthink11/dw17 | 0 | 0 | null | null | null | null | Jupyter Notebook | false | false | .py | 85,247 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# +
# author - Richard Liao
# Dec 26 2016
# https://ri... | 11,412 |
/COVID_PREDICTION.ipynb | f4c7d4dbfafee648d5ce9c32616ca0977dd8b495 | [] | no_license | pd1298/COVID19-PREDICTION | https://github.com/pd1298/COVID19-PREDICTION | 0 | 0 | null | null | null | null | Jupyter Notebook | false | false | .py | 589,233 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# name: python3
# ---
# + [markdown] id="0ccIvQkU96Zo" colab_type="text"
# Importing Important Libr... | 18,322 |
/09_Youtube_Data_Analysis/UseCase_9.ipynb | 63a5f6b00ea1f86fd2350ae45ed473a06485fbc8 | [] | no_license | VarunCK25/UseCases_PySpark | https://github.com/VarunCK25/UseCases_PySpark | 0 | 0 | null | null | null | null | Jupyter Notebook | false | false | .py | 10,292 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# # Youtube Data Analysis
# This usecase is about ana... | 2,349 |
/Uber.ipynb | b6a09901424616baac308575dfc41ff8d0f0e048 | [] | no_license | ScottSmith59/Driving | https://github.com/ScottSmith59/Driving | 0 | 0 | null | null | null | null | Jupyter Notebook | false | false | .py | 304,717 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# +
import pandas as pd
import numpy as np
from dateti... | 3,011 |
/dataset creation using beautifulsoup.ipynb | 18f2ea8b42b3e1c4b466a3d94080a076c3e19b68 | [
"MIT"
] | permissive | ranjankoirala1998/predict-box-office-revenue-with-simple-linear-regression | https://github.com/ranjankoirala1998/predict-box-office-revenue-with-simple-linear-regression | 0 | 0 | null | null | null | null | Jupyter Notebook | false | false | .py | 3,106 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
#Import necessary Libraries
import numpy as np
import ... | 53,979 |
/k-nearest Neighbors (kNN).ipynb | 13928c0db0b312ebfd4e015cc086ba97b32a7885 | [] | no_license | KamingYip/Trading_Strategies_with_Stock_Data_Updating | https://github.com/KamingYip/Trading_Strategies_with_Stock_Data_Updating | 0 | 0 | null | null | null | null | Jupyter Notebook | false | false | .py | 156,730 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# # <div align="center">Data Science with Stock Data -... | 21,771 |
/Data Visualization.ipynb | a17d8f03decc66845d662dad998b494f88e0f507 | [] | no_license | Vishal425/Data-Visualization | https://github.com/Vishal425/Data-Visualization | 0 | 0 | null | null | null | null | Jupyter Notebook | false | false | .py | 106,309 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
import matplotlib.pyplot as plt
#Array, list, Tupples ... | 1,522 |
/42_rnn_seq2seq_colab.ipynb | d1a50d0108da80ccda2ed43a3c539861412ac46c | [] | no_license | gubosd/lecture18 | https://github.com/gubosd/lecture18 | 1 | 2 | null | null | null | null | Jupyter Notebook | false | false | .py | 80,566 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# + [markdown] id="h_GAwHdc1_fH"
# ## 자연어 처리 딥러닝
# # S... | 8,750 |
/03_Audio_Data_Model_MFCC.ipynb | c10a12727707eb8504efe4556a906a68a4b85d4f | [
"LicenseRef-scancode-unknown-license-reference",
"Apache-2.0"
] | permissive | ryanbales/Audio-Data-Insights | https://github.com/ryanbales/Audio-Data-Insights | 10 | 3 | Apache-2.0 | 2022-11-21T21:23:27 | 2020-10-24T20:07:22 | Jupyter Notebook | Jupyter Notebook | false | false | .py | 89,395 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# # Building an Audio Data Model using MFCC Features
... | 5,132 |
/Super_Resolution- GAN.ipynb | 1034df0af1cf8d5d3d92b8d0789705b5ee2fd5e5 | [] | no_license | Ram-5508/Super-Resolution--GAN | https://github.com/Ram-5508/Super-Resolution--GAN | 0 | 0 | null | null | null | null | Jupyter Notebook | false | false | .py | 2,701,635 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# # Task 1 : Linear Regression with Python
# ## Name ... | 16,725 |
/Python Dev/python_assignment.ipynb | 099819126d7c47f88e1ea066e6881b103249bca0 | [
"MIT"
] | permissive | Buhle/Assessments | https://github.com/Buhle/Assessments | 0 | 0 | MIT | 2020-04-01T14:02:52 | 2019-04-04T06:58:24 | null | Jupyter Notebook | false | false | .py | 9,193 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# +
import datetime
import json
import numpy as np
imp... | 4,353 |
/univariate-linear-regression.ipynb | 405dd9c2e532caae188df4907698a4cea28c6f5c | [] | no_license | cricketjanoon/linear-regression-pytorch | https://github.com/cricketjanoon/linear-regression-pytorch | 0 | 0 | null | null | null | null | Jupyter Notebook | false | false | .py | 32,218 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: pytorch-gpu
# language: python
# name: pytorch-gpu
# ---
import torch
import pandas as pd
from matplotli... | 1,640 |
/notebooks/aggregations-joins-sparksql.ipynb | 008166feaa2d81073f8b94a951cdfd3a3d14756a | [] | no_license | parijatbanik/spark-examples | https://github.com/parijatbanik/spark-examples | 0 | 0 | null | null | null | null | Jupyter Notebook | false | false | .py | 48,219 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# ## Examples for Aggregation functions, joins and SQL... | 4,123 |
/Utils/train_interactive.ipynb | 83189212600210b8d295a8f4af37cdaf43ea37ec | [] | no_license | carlmoore256/VR-ML-Drumkit | https://github.com/carlmoore256/VR-ML-Drumkit | 3 | 0 | null | null | null | null | Jupyter Notebook | false | false | .py | 19,686 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: 'Python 3.7.7 64-bit (''venv'': venv)'
# name: python37764bitvenvvenvab0f665d5e6242889e1be50fddda4d67
# ---
... | 1,461 |
/0_Functions.ipynb | 3729dbe48249b30387687824abb1e711d2114bcc | [] | no_license | Ebanchous/Banks_insolvency_forecast_ML | https://github.com/Ebanchous/Banks_insolvency_forecast_ML | 11 | 0 | null | null | null | null | Jupyter Notebook | false | false | .py | 11,121 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# +
# %%time
import pandas as pd
print('''по счетам по... | 8,009 |
/HandsOnMachineLearning2_Chapter3.ipynb | 993f6177f5e342237c00be9acaa6b2e1c5a0123f | [] | no_license | Jangsehawn/HandsOnMachineLearning2 | https://github.com/Jangsehawn/HandsOnMachineLearning2 | 1 | 0 | null | null | null | null | Jupyter Notebook | false | false | .py | 59,606 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# ## Capítulo 1.1.: Modelos estadísticos para control ... | 8,022 |
/python - time series.ipynb | dfe9075c860dd8746e81acceedd0a3f74ea075b3 | [] | no_license | thomashuan88/python_ml | https://github.com/thomashuan88/python_ml | 0 | 0 | null | null | null | null | Jupyter Notebook | false | false | .py | 99,513 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# %pwd
# https://stackabuse.com/time-series-analysis-w... | 5,537 |
/Simulation_state-based_2ndTask/MATLAB-Funktion_und_LyapunovBoundaryPlotting.ipynb | d870ec543651a4bde549e81f911e1a39d0e80c81 | [
"MIT"
] | permissive | ipa-lth/jupyter_nb | https://github.com/ipa-lth/jupyter_nb | 0 | 2 | null | 2017-09-29T07:57:32 | 2016-12-13T10:42:20 | Jupyter Notebook | Jupyter Notebook | false | false | .py | 16,089 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# # 机器学习工程师纳米学位
# ## 模型评价与验证
# ## 项目 1: 预测波士顿房价
#
#
# ... | 16,787 |
/EDA_with_Personal_Email_Analysis.ipynb | 36c6da0b0d1babfef7a64890b42d3bd2951dea13 | [] | no_license | omarn8911/Dphi-MLBootCamp | https://github.com/omarn8911/Dphi-MLBootCamp | 0 | 0 | null | null | null | null | Jupyter Notebook | false | false | .py | 1,922,595 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# # 01_Tokenization of paragraphs_sentences
import nl... | 17,555 |
/qqplot/qqplot_no2.ipynb | 707a3604ea491e10729542cf1804bd9840d84f83 | [] | no_license | saireddythfc/Air-Quality-Index-Analysis | https://github.com/saireddythfc/Air-Quality-Index-Analysis | 0 | 0 | null | 2019-12-03T12:31:28 | 2019-12-03T12:28:37 | null | Jupyter Notebook | false | false | .py | 33,812 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
import pandas as pd
import numpy as np
from scipy.spec... | 1,364 |
/12_solid.ipynb | 524d3babf7138fd79b24acffd7683bf8e31f99cc | [] | no_license | SalmonMoses/oop2020 | https://github.com/SalmonMoses/oop2020 | 0 | 0 | null | 2021-05-08T21:33:31 | 2021-04-17T20:27:40 | Jupyter Notebook | Jupyter Notebook | false | false | .py | 25,000 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# name: python3
# ---
# + [markdown] id="GBgYUDM7VwUm"
# # ThinkDSP课后习题
# + [markdown] id="AE5o0EY... | 15,660 |
/modules/autoencoder_mednist.ipynb | ce0013f8093546e25bb49f07f1d57586ac10cc86 | [
"Apache-2.0"
] | permissive | szh13818253048/tutorials | https://github.com/szh13818253048/tutorials | 0 | 0 | null | null | null | null | Jupyter Notebook | false | false | .py | 238,335 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
import numpy as np
import csv
from extract import Extr... | 9,033 |
/.ipynb_checkpoints/DSherrill Map two excel worksheets using Python - Five Minute Python Automation Scripts-checkpoint.ipynb | c35a9fa35bc67b7a86f2e46185430ad56a2e08c9 | [] | no_license | ulrikSebastienR/Python-Diaries | https://github.com/ulrikSebastienR/Python-Diaries | 0 | 0 | null | null | null | null | Jupyter Notebook | false | false | .py | 8,898 | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.5'
# jupytext_version: 1.15.2
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# trying out https://www.youtube.com/watch?v=OB_ixIlQb... | 1,024 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.