{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"pygments_lexer":"ipython3","nbconvert_exporter":"python","version":"3.6.4","file_extension":".py","codemirror_mode":{"name":"ipython","version":3},"name":"python","mimetype":"text/x-python"}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"code","source":"import numpy as np\nimport pandas as pd\nimport scipy.stats as stats\nfrom multiprocessing import Process, Manager\nimport multiprocessing as mp\nimport random\nimport matplotlib.pyplot as plt\nimport seaborn as sns\n\nimport torch\nimport torch.nn as nn\nfrom torch.nn import functional as F\n\nfrom sklearn.metrics import classification_report\nfrom sklearn.preprocessing import StandardScaler, MinMaxScaler\nfrom sklearn.linear_model import LinearRegression\nfrom statsmodels.tsa.seasonal import seasonal_decompose\nfrom scipy.optimize import curve_fit\n\nimport gc\nimport warnings\nwarnings.filterwarnings('ignore')","metadata":{"id":"mXvnzeF7qI4o","execution":{"iopub.status.busy":"2023-10-15T10:33:27.853991Z","iopub.execute_input":"2023-10-15T10:33:27.854423Z","iopub.status.idle":"2023-10-15T10:33:34.018423Z","shell.execute_reply.started":"2023-10-15T10:33:27.854393Z","shell.execute_reply":"2023-10-15T10:33:34.017482Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Functions","metadata":{}},{"cell_type":"code","source":"# clip upper and lower 10 percentile\n\ndef clipper(series):\n upper = np.percentile(series, 90)\n lower = np.percentile(series, 10)\n\n if series.min()==0:\n series = series.apply(lambda x: upper if x>upper else x)\n\n else:\n series = series.apply(lambda x: upper if x>upper else x)\n series = series.apply(lambda x: lower if x 1:\n checker = nn.DataParallel(checker)\n \n \nchecker = checker.to(device)\n\npos_optimiser = torch.optim.Adam(checker.parameters(), lr=1e-3)","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"for pep in range(700): \n\n for i in range(0, len(posxtn), 200):\n X = posxtn[i: i+200]\n Y = posytn[i: i+200]\n \n yout = checker(X)\n pos_loss = torch.zeros(len(Y))\n \n for i, item in enumerate(zip(yout, Y)):\n pos_loss[i] = F.cross_entropy(item[0], item[1], weight=pos_class_weight)\n \n mean_pos_loss = pos_loss.mean()\n \n pos_optimiser.zero_grad()\n mean_pos_loss.backward()\n pos_optimiser.step()\n \n if pep%100==0:\n with torch.no_grad():\n tnout = checker(posxtn)\n tsout = checker(posxts)\n \n pos1 = torch.zeros(len(posytn))\n pos2 = torch.zeros(len(posyts))\n \n for i, item in enumerate(zip(tnout, posytn)):\n pos1[i] = F.cross_entropy(item[0], item[1], weight=pos_class_weight)\n \n for i, item in enumerate(zip(tsout, posyts)):\n pos2[i] = F.cross_entropy(item[0], item[1], weight=pos_class_weight)\n \n \n print(f\"Epoch: {pep}, Training loss: {pos1.mean()}, Test loss: {pos2.mean()}\")","metadata":{"execution":{"iopub.status.busy":"2023-10-15T14:53:46.914998Z","iopub.execute_input":"2023-10-15T14:53:46.916837Z","iopub.status.idle":"2023-10-15T15:19:31.746291Z","shell.execute_reply.started":"2023-10-15T14:53:46.916772Z","shell.execute_reply":"2023-10-15T15:19:31.744182Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"df = test_dict[random.choice(test_id)]\ndf = df[df.event!=0][['elements', 'oevent']].reset_index(drop=True)\ndf['rmean'] = [pd.Series(x).rolling(3).mean().fillna(method='ffill').fillna(method='bfill') for x in df.elements]\ndf['del'] = [(pd.Series(x).diff(-1) * -1).fillna(value=0.0) for x in df.elements]","metadata":{"execution":{"iopub.status.busy":"2023-10-15T15:20:36.845651Z","iopub.execute_input":"2023-10-15T15:20:36.846209Z","iopub.status.idle":"2023-10-15T15:20:37.141820Z","shell.execute_reply.started":"2023-10-15T15:20:36.846174Z","shell.execute_reply":"2023-10-15T15:20:37.140597Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def pos_predicted(out_tens):\n out_tens = out_tens.cpu()\n scores = torch.max(F.softmax(out_tens, dim=1), dim=1)[0]\n out_tens = torch.argmax(F.softmax(out_tens, dim=1), dim=1)\n scores = scores * out_tens\n \n predicted = [x if i==torch.argmax(scores) else 0 for i, x in enumerate(out_tens)]\n \n return predicted","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"rand_pos = random.choice(df.index)\ninpt = torch.tensor(df[['rmean', 'del', 'elements']].loc[rand_pos], dtype=torch.float32)\ninpt = torch.transpose(inpt.unsqueeze(0), 1, 2)\ninpt = inpt.to(device)\n\nwith torch.no_grad():\n outpt = checker(inpt).squeeze(0)\n\n# scores = torch.max(F.softmax(outpt, dim=1), dim=1)[0]\n# outpt = torch.argmax(F.softmax(outpt, dim=1), dim=1)\n# scores = scores * outpt\npos_pred = pos_predicted(outpt)","metadata":{"execution":{"iopub.status.busy":"2023-10-15T15:21:43.870297Z","iopub.execute_input":"2023-10-15T15:21:43.870709Z","iopub.status.idle":"2023-10-15T15:21:43.882678Z","shell.execute_reply.started":"2023-10-15T15:21:43.870677Z","shell.execute_reply":"2023-10-15T15:21:43.881341Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"plt.plot(df.elements.loc[rand_pos])\nplt.plot(df.rmean.loc[rand_pos], linestyle='dotted')\nplt.plot(df.oevent.loc[rand_pos], color='black')\nplt.plot(pos_pred, color='red')\nplt.show()","metadata":{"execution":{"iopub.status.busy":"2023-10-15T15:21:38.986455Z","iopub.execute_input":"2023-10-15T15:21:38.986870Z","iopub.status.idle":"2023-10-15T15:21:39.246041Z","shell.execute_reply.started":"2023-10-15T15:21:38.986839Z","shell.execute_reply":"2023-10-15T15:21:39.244933Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"del df","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Autoencoding for embedding series windows","metadata":{"id":"1z33TtjCQxBC"}},{"cell_type":"code","source":"# the window embedding is a general operation independent of series id or timestamp\n# every window's own temporal sequence is relevant only, therefore all the windows can be stacked together\n\ntrain_series = pd.concat([x['elements'] for x in train_dict.values()], ignore_index=True).reset_index(drop=True)\ntest_series = pd.concat([x['elements'] for x in test_dict.values()], ignore_index=True).reset_index(drop=True)","metadata":{"id":"eZNON_95rUq4","trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# stacks tensors of shape (1, window size) giving a tensor of shape (train samples, window size) \n\ntn_conv_inp = torch.stack([torch.tensor(x, dtype=torch.float32) for x in train_series])\nts_conv_inp = torch.stack([torch.tensor(x, dtype=torch.float32) for x in test_series])\n\ndel train_series, test_series","metadata":{"id":"gSc6Q7Qmr6RR","trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# pads a 2d tensor with 2d zero tensors for uniformity in sequence length required for model input\n\ndef pad_seq(tnsr, size, gpsize):\n \n length = len(tnsr)\n\n if length%size!=0:\n pad_length = (np.ceil(length/size).astype('int')*size) - length\n\n tnsr = torch.cat((tnsr, torch.zeros((pad_length, gpsize))), dim=0)\n \n return length, tnsr","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"batch_enc = 10000 # batch size to train auto encoder\n\n\n# as the autoencoder also uses a convolution layer for which batch size must be uniform\n# padding both train and test tensors so that number of samples is a multiple of batch size\n# if not padded, possibility of last batch containing less samples than batch size resulting in error\n\ntrain_original_length, tn_conv_inp = pad_seq(tn_conv_inp, batch_enc, grouper)\ntest_original_length, ts_conv_inp = pad_seq(ts_conv_inp, batch_enc, grouper)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# simple convolution model \n\nclass convolution(nn.Module):\n\n def __init__(self, ssize, lng):\n super().__init__()\n msize = int(ssize/2) # as the task is split between 2 GPUs each with half of the batch\n \n self.conv = nn.Conv1d(msize, msize, 5, padding=\"same\")\n self.relu = nn.ReLU()\n # self.bnorm = nn.BatchNorm1d(ssize)\n self.lnorm = nn.LayerNorm(lng)\n\n def forward(self, x):\n\n x = self.conv(x)\n x = self.relu(x)\n\n # x = x.unsqueeze(0)\n # x = self.bnorm(x)\n # out = x.squeeze(0)\n \n out = self.lnorm(x)\n\n return out\n","metadata":{"id":"Pd18rjh0sAC9","trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"class autoencoder(nn.Module):\n\n def __init__(self, ssize, sizez):\n super().__init__()\n\n self.conv = convolution(ssize, sizez)\n \n embed_size = 2 # specifying what size the window series must be embedded down to\n \n self.enc1 = nn.LSTM(input_size=1, hidden_size=32, num_layers=1, batch_first=True, bidirectional=False)\n self.enc2 = nn.LSTM(input_size=32, hidden_size=16, num_layers=1, batch_first=True, bidirectional=False)\n self.enc3 = nn.LSTM(input_size=16, hidden_size=embed_size, num_layers=1, batch_first=True, bidirectional=False)\n\n self.dec1 = nn.LSTM(input_size=embed_size, hidden_size=embed_size, num_layers=1, batch_first=True, bidirectional=False)\n self.dec2 = nn.LSTM(input_size=embed_size, hidden_size=16, num_layers=1, batch_first=True, bidirectional=False)\n self.dec3 = nn.LSTM(input_size=16, hidden_size=32, num_layers=1, batch_first=True, bidirectional=False)\n\n self.otp = nn.Linear(32, 1)\n\n\n def forward(self, x):\n x = x.squeeze(2)\n x = self.conv(x)\n x = x.unsqueeze(2)\n\n x, _ = self.enc1(x)\n x, _ = self.enc2(x)\n x, (hid, _) = self.enc3(x) # window series of size 25 or 50 or 100 embedded down to 2 or 4 (as chosen)\n\n x = torch.transpose(hid, 0, 1)\n x = torch.flatten(x, start_dim=1).unsqueeze(1)\n x = x.repeat(1, grouper, 1)\n\n x, _ = self.dec1(x)\n x, _ = self.dec2(x)\n x, _ = self.dec3(x)\n\n out = self.otp(x) # reconstructed window series\n\n return out, hid\n","metadata":{"id":"ITNXcECol7j1","trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"model = autoencoder(batch_enc, grouper)\n\nae_lr = 1e-3\n\nif torch.cuda.device_count() > 1:\n model = nn.DataParallel(model)\n \nmodel = model.to(device)\n\noptimizer = torch.optim.Adam(model.parameters(), lr=ae_lr)","metadata":{"id":"PU18e4chIUMc","trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"for ep in range(50):\n\n batch_loss = torch.zeros(batch_enc) # stores mse loss in each batch of size batch_enc \n\n for b in range(0, len(tn_conv_inp), batch_enc):\n xi = tn_conv_inp[b: b+batch_enc]\n xi = xi.unsqueeze(2) # expanding the (sample size, window size) to (sample size, window size, 1) ~ (batches, samples, features)\n xi = xi.to(device)\n\n y, _ = model(xi)\n\n mean_loss = F.mse_loss(y, xi, reduction='mean') # input is the ground truth for reconstruction\n optimizer.zero_grad()\n mean_loss.backward(retain_graph=True)\n optimizer.step()\n\n \n if ep==20:\n ae_lr = 1e-5 # decrease learning rate at epoch 20\n \n if ep%5==0:\n\n lozz = torch.zeros(np.ceil(len(tn_conv_inp)/batch_enc).astype('int')) # stores evaluation mse loss in each batch of size batch_enc \n lid = 0\n\n for i in range(0, len(tn_conv_inp), batch_enc):\n xi = tn_conv_inp[i: i+batch_enc]\n xi = xi.unsqueeze(2)\n xi = xi.to(device)\n\n model.eval()\n with torch.no_grad():\n rec, _ = model(xi)\n rec_loss = F.mse_loss(rec, xi, reduction='mean')\n lozz[lid] = rec_loss\n model.train()\n lid+=1\n print(f\"Epoch: {ep}, Reconstruction loss: {lozz.mean()}\")\n\n# else:\n# print(f\"Epoch: {ep}\")\n\n","metadata":{"id":"9yx5TQCMgmMT","outputId":"75149eb0-e744-4352-8710-9acdd33ea1d1","trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# use the window embeddings as feature that represents the original windowed series\n# create a new feature for reconstruction error for wach window\n\n# creating a function to apply above on each train/test series separately as it is difficult to split the clubbed data into its constituent series\n\ndef embed_out(df):\n \n input_tensor = torch.stack([torch.tensor(x, dtype=torch.float32) for x in df['elements']])\n \n original_length, input_tensor = pad_seq(input_tensor, batch_enc, grouper)\n \n\n for i in range(0, len(input_tensor), batch_enc):\n xi = input_tensor[i: i+batch_enc]\n xi = xi.unsqueeze(2)\n xi = xi.to(device)\n\n with torch.no_grad():\n if i==0:\n out, hd = model(xi) # the first batch creates 2 tensors out and hd to which succeeding batches will concatenate data\n\n else:\n o, h = model(xi)\n out = torch.cat((out, o), dim=0) # concatenates by dim 0 as it pertains to the batch dimension for the final output. Shape (batch, seq length, 1)\n hd = torch.cat((hd, h), dim=1) # concatenates by dim 1 as it pertains to the batch dimension for the hidden state (embedding state). Shape (1, batch, embed length)\n\n\n out = out.squeeze(2) # remove 3rd dimension of output to give a 2d tensor (df length, window size)\n\n hd = torch.flatten(hd, start_dim=0, end_dim=1).squeeze(0) # flattening before squeezing dim 0 as shape was (2, batch, embed length) as 2 parallel GPUs were used\n \n\n out = out[:original_length] # remove padding values by slicing outputs back to original length\n hd = hd[:original_length]\n\n \n \n # make new feature for reconstruction error\n \n err = []\n\n for s1, s2 in zip(input_tensor, out):\n s1 = s1.to(device)\n err.append(F.mse_loss(s1, s2, reduction='mean').item())\n\n df['rec_loss'] = err\n\n \n # add features for window embeddings. Using them as features to represent the original window of type tensor\n hd = torch.transpose(hd, 0, 1)\n \n for n in range(len(hd)):\n df['embedded'+str(n)] = hd[n].cpu()\n\n\n del out, hd\n\n\n return df","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# add embedded series window and reconstruction loss to train and test dictionaries\n\nfor k in train_dict.keys():\n train_dict[k] = embed_out(train_dict[k])","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"for k in test_dict.keys():\n test_dict[k] = embed_out(test_dict[k])","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"gc.collect()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"columns = train_dict[rnd].columns.values\nfeatures = [x for x in columns if x not in ['step', 'elements', 'event']]\nlabels = 'event'","metadata":{"id":"zmx3NLNp9BSB","trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# pads each series in a dictionary so that lengths match the longest series across the workspace, returns padded tensors and original length\n\ndef pseudo_stacker(dictn, features, labels, max_l):\n lengths = []\n for i, k in enumerate(dictn.keys()):\n if i==0:\n xval = torch.tensor(dictn[k][features].to_numpy(), dtype=torch.float32)\n xl, xr = pad_seq(xval, max_l, len(features))\n xr = xr.unsqueeze(0)\n yval = torch.tensor(dictn[k][labels].to_numpy(), dtype=torch.int64)\n ypad = max_l - xl\n yr = torch.cat((yval, torch.zeros(ypad)))\n yr = yr.unsqueeze(0)\n lengths.append(xl)\n del xval, yval\n \n else:\n xval = torch.tensor(dictn[k][features].to_numpy(), dtype=torch.float32)\n xl, x = pad_seq(xval, max_l, len(features))\n x = x.unsqueeze(0)\n yval = torch.tensor(dictn[k][labels].to_numpy(), dtype=torch.int64)\n ypad = max_l - xl\n y = torch.cat((yval, torch.zeros(ypad)))\n y = y.unsqueeze(0)\n lengths.append(xl)\n del xval, yval\n \n xr = torch.cat((xr, x), dim=0)\n yr = torch.cat((yr, y), dim=0)\n \n \n return lengths, xr, yr.to(torch.int64)","metadata":{"id":"9PCMu3YZ6vxb","trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# predicting the events at an individual level prevents us from clubbing all the series together\n# temporal sequence of individual series has to be kept separate and all series have to have uniform length, therefore padding is performed\n# each individual series will be treated as a batch\n\nmax_l = np.max([len(x) for x in train_dict.values()] + [len(x) for x in test_dict.values()]) # length of the longest series among train + test\ntrain_l, x_train, y_train = pseudo_stacker(train_dict, features, labels, max_l)\ntest_l, x_test, y_test = pseudo_stacker(test_dict, features, labels, max_l)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# getting weights for each of the classes 0, 1 and 2 by inverse frequency method as dataset is highly imbalanced\n# oversampling for temporally related samples seems ill advised\n\nunq_elm, cnts = torch.unique(torch.flatten(y_train), return_counts=True)\nclass_weight = dict(sorted(zip(unq_elm, cnts)))\nclass_weight = torch.tensor([1/k.item() for k in class_weight.values()], dtype=torch.float32)\nclass_weight = class_weight.to(device)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# sequence to sequence analysis trained on each series window and associated features and labels on whether that window contains an event\n# individual series id is a batch\n\nclass seq2seq(nn.Module):\n \n def __init__(self, in_size):\n super().__init__()\n \n # using a bidirectional LSTM in this case\n \n self.seq1 = nn.LSTM(input_size=in_size, hidden_size=16, num_layers=1, batch_first=True, bidirectional=True)\n self.seq2 = nn.LSTM(input_size=16*2, hidden_size=16, num_layers=1, batch_first=True, bidirectional=True)\n self.seq3 = nn.LSTM(input_size=16*2, hidden_size=8, num_layers=1, batch_first=True, bidirectional=True)\n \n self.lin = nn.Linear(8*2, 3)\n \n def forward(self, x):\n \n x, _ = self.seq1(x)\n x, _ = self.seq2(x)\n x, _ = self.seq3(x)\n out = self.lin(x)\n \n return out\n ","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"classif = seq2seq(len(features))\n\nif torch.cuda.device_count() > 1:\n classif = nn.DataParallel(classif)\n \n \nclassif = classif.to(device)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# evaluation losses\n\n@torch.no_grad()\ndef get_losses():\n classif.eval()\n \n # as each series is a batch, we can use them as input one at a time without having to set batch size\n\n train_loss = torch.zeros(len(y_train))\n for i, item in enumerate(zip(x_train, y_train)):\n x, y = item[0].to(device), item[1].to(device)\n ptn = classif(x.unsqueeze(0))\n train_loss[i] = F.cross_entropy(ptn.squeeze(0)[:train_l[i]], y[:train_l[i]], weight=class_weight)\n\n test_loss = torch.zeros(len(y_test))\n for j, jtem in enumerate(zip(x_test, y_test)):\n x, y = jtem[0].to(device), jtem[1].to(device)\n pts = classif(x.unsqueeze(0))\n test_loss[j] = F.cross_entropy(pts.squeeze(0)[:test_l[j]], y[:test_l[j]], weight=class_weight)\n\n print(f\"Training loss: {train_loss.mean():.05f}, Validation loss: {test_loss.mean():.05f}\") # mean cross entropy loss over all batches\n\n classif.train()","metadata":{"id":"Cx9IjJKvHPmh","trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"optimiser = torch.optim.Adam(classif.parameters(), lr=1e-3)\n\nfor epp in range(20):\n\n for i, inp in enumerate(zip(x_train, y_train)):\n \n # as each series is a batch, we can use them as input one at a time without having to set batch size\n\n x_inp = inp[0].to(device)\n y_lab = inp[1].to(device)\n logits = classif(x_inp)\n\n # squeezing logits as output is of the shape (1, n, 3) as it contains a batch dimension whereas the ground truth is of shape (n, 1)\n lozzes = F.cross_entropy(logits.squeeze(0)[:train_l[i]], y_lab[:train_l[i]], weight=class_weight)\n\n optimiser.zero_grad()\n lozzes.backward()\n optimiser.step()\n\n if epp%2==0:\n print(f\"Epoch: {epp}\", end=\" \")\n get_losses()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# checking result on any random test series\nrand_test = random.choice(np.arange(len(test_dict)))\ntest = test_dict[list(test_dict.keys())[rand_test]]\n\n\nwith torch.no_grad():\n x_pr = x_test[rand_test].to(device)\n pr = classif(x_pr)\n\n out_probs = F.softmax(pr.squeeze(0), dim=1) # predicted class probabilities\n preds = torch.argmax(out_probs, dim=1) # max probability class\n scores = torch.max(out_probs, dim=1) # probability or confidence scores\n \n preds = preds[:test_l[rand_test]] # removing the padded section for this specific series\n\npredictions = preds.cpu().numpy()\nconfidence = scores[0].cpu().numpy()[:test_l[rand_test]] # scores[0] indexed because torch.max() returns a tuple where first element is the max value\ntest['pevent'] = predictions\ntest['conf'] = confidence","metadata":{"id":"OcKIAdSMIeFC","trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"plt.figure(figsize=(30, 4))\n\nplt.plot(test['step'], test['trend'])\n\n# ground truths\nfor i in test[test.event==1].index:\n plt.axvline(x=i, color='black', linestyle='solid', linewidth=10, alpha=0.3)\nfor i in test[test.event==2].index:\n plt.axvline(x=i, color='orange', linestyle='solid', linewidth=10, alpha=0.3)\n \n# predictions with more than 0.99 probability\nfor i in test[(test.pevent==1) & (test.conf>0.99)].index:\n plt.axvline(x=i, color='black', linestyle='dashed')\nfor i in test[(test.pevent==2) & (test.conf>0.99)].index:\n plt.axvline(x=i, color='orange', linestyle='dashed')\n\nplt.show() # observation, quite a good result","metadata":{"id":"8LRxRm0f5xBz","outputId":"f9c7acb1-76ab-4f0b-fd0d-16c5ec7808d1","trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"","metadata":{},"execution_count":null,"outputs":[]}]}