{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"name":"python","version":"3.10.13","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"},"kaggle":{"accelerator":"gpu","dataSources":[{"sourceId":70367,"databundleVersionId":9188054,"sourceType":"competition"},{"sourceId":9654201,"sourceType":"datasetVersion","datasetId":5897326}],"dockerImageVersionId":30747,"isInternetEnabled":false,"language":"python","sourceType":"notebook","isGpuEnabled":true}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"code","source":"import pandas as pd\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport seaborn as sns\nimport scipy.stats\nfrom tqdm import tqdm\n\nfrom sklearn.model_selection import cross_val_predict\nfrom sklearn.linear_model import Ridge\nfrom sklearn.metrics import r2_score, mean_squared_error\nimport itertools\nfrom scipy.optimize import minimize\nfrom functools import partial\nimport random, os\nfrom astropy.stats import sigma_clip\nfrom scipy.signal import savgol_filter\nfrom scipy.optimize import minimize\nfrom sklearn.preprocessing import PolynomialFeatures\nfrom sklearn.linear_model import LinearRegression\nimport polars as pl\n\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F","metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","execution":{"iopub.status.busy":"2024-08-29T08:21:38.713677Z","iopub.execute_input":"2024-08-29T08:21:38.714176Z","iopub.status.idle":"2024-08-29T08:21:45.918124Z","shell.execute_reply.started":"2024-08-29T08:21:38.714128Z","shell.execute_reply":"2024-08-29T08:21:45.916397Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"test_adc_info = pd.read_csv('/kaggle/input/ariel-data-challenge-2024/test_adc_info.csv',\n                           index_col='planet_id')","metadata":{"execution":{"iopub.status.busy":"2024-08-29T08:21:45.921158Z","iopub.execute_input":"2024-08-29T08:21:45.92215Z","iopub.status.idle":"2024-08-29T08:21:46.160388Z","shell.execute_reply.started":"2024-08-29T08:21:45.922074Z","shell.execute_reply":"2024-08-29T08:21:46.158543Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"def apply_linear_corr(linear_corr,clean_signal):\n    linear_corr = np.flip(linear_corr, axis=0)\n    for x, y in itertools.product(\n                range(clean_signal.shape[1]), range(clean_signal.shape[2])\n            ):\n        poli = np.poly1d(linear_corr[:, x, y])\n        clean_signal[:, x, y] = poli(clean_signal[:, x, y])\n    return clean_signal\n\ndef clean_dark(signal, dark, dt):\n    dark = np.tile(dark, (signal.shape[0], 1, 1))\n    signal -= dark* dt[:, np.newaxis, np.newaxis]\n    return signal\n\ndef preproc(dataset, adc_info, sensor, binning = 15):\n    sensor_sizes_dict = {\"AIRS-CH0\":[[11250, 32, 356], [1, 32, 356]], \"FGS1\":[[135000, 32, 32], [1, 32, 32]]}\n    binned_dict = {\"AIRS-CH0\":[11250 // binning // 2, 356], \"FGS1\":[135000 // binning // 2]}\n    linear_corr_dict = {\"AIRS-CH0\":(6, 32, 356), \"FGS1\":(6, 32, 32)}\n    planet_ids = adc_info.index\n    \n    feats = []\n    for i, planet_id in tqdm(list(enumerate(planet_ids))):\n        signal = pl.read_parquet(f'/kaggle/input/ariel-data-challenge-2024/{dataset}/{planet_id}/{sensor}_signal.parquet').cast(pl.Float32).to_numpy()\n        dark_frame = pl.read_parquet(f'/kaggle/input/ariel-data-challenge-2024/{dataset}/' + str(planet_id) + '/' + sensor + '_calibration/dark.parquet').cast(pl.Float32).to_numpy()\n        dead_frame = pl.read_parquet(f'/kaggle/input/ariel-data-challenge-2024/{dataset}/' + str(planet_id) + '/' + sensor + '_calibration/dead.parquet').cast(pl.Boolean).to_numpy()\n        flat_frame = pl.read_parquet(f'/kaggle/input/ariel-data-challenge-2024/{dataset}/' + str(planet_id) + '/' + sensor + '_calibration/flat.parquet').cast(pl.Float32).to_numpy()\n        linear_corr = pl.read_parquet(f'/kaggle/input/ariel-data-challenge-2024/{dataset}/' + str(planet_id) + '/' + sensor + '_calibration/linear_corr.parquet').cast(pl.Float32).to_numpy().reshape(linear_corr_dict[sensor])\n\n        signal = signal.reshape(sensor_sizes_dict[sensor][0]) \n        gain = adc_info[f'{sensor}_adc_gain'].values[i]\n        offset = adc_info[f'{sensor}_adc_offset'].values[i]\n        signal = signal / gain + offset\n        \n        hot = sigma_clip(\n            dark_frame, sigma=6, maxiters=5\n        ).mask\n        \n        if sensor != \"FGS1\":\n            signal = signal #11250 * 32 * 282\n            #dt = axis_info['AIRS-CH0-integration_time'].dropna().values\n            dt = np.ones(len(signal))*0.1 \n            dt[1::2] += 4.5\n        else:\n            dt = np.ones(len(signal))*0.1\n            dt[1::2] += 0.1\n            \n        signal = signal.clip(0)\n        linear_corr_signal = apply_linear_corr(linear_corr, signal)\n        signal = clean_dark(linear_corr_signal, dark_frame, dt)\n        \n        flat = flat_frame.reshape(sensor_sizes_dict[sensor][1])\n        flat[dead_frame.reshape(sensor_sizes_dict[sensor][1])] = np.nan\n        flat[hot.reshape(sensor_sizes_dict[sensor][1])] = np.nan\n        signal = signal / flat\n                \n        if sensor == \"FGS1\":\n            signal = signal.reshape((sensor_sizes_dict[sensor][0][0], sensor_sizes_dict[sensor][0][1]*sensor_sizes_dict[sensor][0][2]))\n        \n        mean_signal = np.nanmean(signal, axis=1) \n        cds_signal = (mean_signal[1::2] - mean_signal[0::2])\n        \n        binned = np.zeros((binned_dict[sensor]))\n        for j in range(cds_signal.shape[0] // binning):\n            binned[j] = cds_signal[j*binning:j*binning+binning].mean(axis=0)\n                   \n        if sensor == \"FGS1\":\n            binned = binned.reshape((binned.shape[0],1))\n            \n        feats.append(binned)\n        \n    return np.stack(feats)\n    \nfull_train = np.concatenate([preproc('test', test_adc_info, \"FGS1\", 12), preproc('test', test_adc_info, \"AIRS-CH0\", 1)], axis=2)","metadata":{"execution":{"iopub.status.busy":"2024-08-29T08:21:46.165819Z","iopub.execute_input":"2024-08-29T08:21:46.166402Z","iopub.status.idle":"2024-08-29T08:21:59.916591Z","shell.execute_reply.started":"2024-08-29T08:21:46.16635Z","shell.execute_reply":"2024-08-29T08:21:59.915491Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"from scipy.signal import savgol_filter\nfrom sklearn.preprocessing import PolynomialFeatures\nfrom sklearn.linear_model import LinearRegression\nfrom scipy.optimize import minimize_scalar\nfrom scipy.stats import norm\n\n\ndef smooth_data(data, window_size, deg=3):\n    return savgol_filter(data, window_size, deg)  # window size 51, polynomial order 3\n\ndef phase_detector(signal, w=5, margin=1, scale=30):\n    phase1, phase2 = None, None\n    midpoint = signal.shape[0] // 2\n    best_drop = 0\n    for i in range(40*scale,82*scale):        \n        t1 = signal[i-w:i+w].max() - signal[i-w:i+w].min()\n        if t1 > best_drop:\n            i_max = i - w + np.argmax(signal[i-w:i+w])\n            i_min = i - w + np.argmax(-signal[i-w:i+w])\n            if i_max > i_min:\n                continue\n\n            best_drop = t1\n            \n            phase1 = (i_max - margin, i_min + margin)\n\n    best_drop = 0\n    for i in range(105*scale,147*scale):        \n        t1 = signal[i-w:i+w].max() - signal[i-w:i+w].min()\n        if t1 > best_drop:\n            i_max = i - w + np.argmax(signal[i-w:i+w])\n            i_min = i - w + np.argmax(-signal[i-w:i+w])\n            if i_min > i_max:\n                continue\n\n            best_drop = t1\n            \n            phase2 = (i_min - margin, i_max + margin)\n\n\n    return phase1[0], phase1[1], phase2[0], phase2[1]\n\n\nclass SignalPoly():\n    def __init__(self, deg):\n        self.deg = deg\n        self.poly_features = PolynomialFeatures(degree=deg, include_bias=True)\n        self.model = LinearRegression()\n        \n    def fit(self, x, y):\n        X_poly = self.poly_features.fit_transform(np.array(x).reshape(-1, 1))\n        self.model.fit(X_poly, y)\n\n    def predict(self, x):\n        X_poly = self.poly_features.transform(np.array(x).reshape(-1, 1))\n        return self.model.predict(X_poly)\n    \ndef f_coef(px, y, s):\n    q = -np.sum(norm.logpdf(y * s, px, 1.0)) \n    return q  \n\ndef try_s_alpenglow2(px, y, s):\n    q = -np.sum(norm.logpdf(y * (1 + s), px, 1.0)) \n    return q\n\ndef calibrate_train_alpenglow2(signal, p0, p1, p2, p3, max_deg=6, min_deg=1):\n    best_deg, best_score, best_s, best_poly = 1, 1e12, 0, None\n    signal = np.asarray(signal)  # ensure signal is a numpy array for faster slicing\n    out = np.concatenate((np.arange(p0), np.arange(p3, signal.shape[0])))  # faster range handling\n    x, y = out, signal[out]\n    x2 = np.arange(p1, p2)\n    y2 = signal[p1:p2]\n\n    for deg in range(min_deg, max_deg):        \n        p = SignalPoly(deg)\n        p.fit(x, y)        \n        px = p.predict(x)\n        q0 = -np.sum(norm.logpdf(y, px, 1.0)) \n\n        px2 = p.predict(x2)\n        f = partial(try_s_alpenglow2, px2, y2)\n        r = minimize_scalar(f, bounds=(1e-5, 1))\n        s = r.x\n        q = q0 + r.fun\n\n        if q < best_score:\n            best_score = q\n            best_poly = p\n            best_s = (1.0 - 1.0 / (1.0 + s))\n            best_deg = deg\n\n    return best_s, best_deg, best_poly, best_score\n\ndef smooth_data_lambda(train_signal, win=3):\n    q = train_signal[:,40-win:322+win]\n    q = q / train_signal[:,40-win:322+win].mean(axis=1, keepdims=True)\n    q_coef = q.mean(axis=0)\n    gauss_coefs = np.array([0.01227215, 0.07819333, 0.23753036, 0.34400831, 0.23753036, 0.07819333, 0.01227215])\n    \n    t_smooth = train_signal[:,40-win:322+win].copy()\n    for l in range(win,t_smooth.shape[1]-win):\n        coefs = q_coef[l-win:l+win+1] / q_coef[l]\n        \n        t_smooth[:,l] = np.dot(train_signal[:,40-win+l-win:40-win+l+win+1] * coefs, gauss_coefs)\n    if win > 0:\n        t_smooth = t_smooth[:,win:-win][:,::-1]\n    else:\n        t_smooth = t_smooth[:,::-1]\n    return np.concatenate([train_signal[:,0:1], t_smooth], axis=1)\n\nfeats = np.zeros((len(full_train),283,11))\nmax_degs = np.zeros(len(full_train)).astype(int)\n\nfor i in tqdm(range(len(full_train))):       \n    train = smooth_data_lambda(full_train[i], 3)\n    \n    ranges = [(0,283)]\n    for r1,r2 in ranges:\n        signal = train[:,r1:r2].mean(axis=1)\n        signal = smooth_data(signal, 330, 3) \n        p0,p1,p2,p3 = phase_detector(signal, 90, margin=30)\n        s,max_deg,_,_ = calibrate_train_alpenglow2(signal, p0,p1,p2,p3)\n        max_degs[i] = max_deg+1\n        feats[i,r1:r2,0] = s\n\n    x_out = np.concatenate((np.arange(p0), np.arange(p3, signal.shape[0])))\n    x_in = np.arange(p1, p2)\n       \n    ranges = [(0,133),(133,283)]\n    for r1,r2 in ranges:\n        signal = train[:,r1:r2].mean(axis=1)\n        signal = smooth_data(signal, 330, 3) \n        s,_,_,_ = calibrate_train_alpenglow2(signal, p0,p1,p2,p3, max_degs[i])\n        feats[i,r1:r2,1] = s\n\n\n    ranges = [(0,62),(62,133),(133,200),(200,283)]\n    for r1,r2 in ranges:\n        signal = train[:,r1:r2].mean(axis=1)\n        signal = smooth_data(signal, 330, 3) \n        s,_,p,_ = calibrate_train_alpenglow2(signal, p0,p1,p2,p3, max_degs[i])\n        feats[i,r1:r2,2] = s\n\n        px = p.predict(np.arange(full_train.shape[1]))\n        for l in range(r1,r2):\n            signal = smooth_data(train[:,l], 330, 3)\n            \n            f = partial(f_coef, px[x_out], signal[x_out])\n            r = minimize_scalar(f)\n            a = r.x\n            score_a = r.fun\n    \n            f = partial(f_coef, px[x_in], signal[x_in])\n            r = minimize_scalar(f)\n            b = r.x\n            score_b = r.fun\n    \n            feats[i,l,7] = (1.0 - a / b)\n\n\n    ranges = [(j*50,50+j*50) for j in range(283//50+1)]\n    for r1,r2 in ranges:\n        signal = train[:,r1:r2].mean(axis=1)\n        signal = smooth_data(signal, 330, 3) \n        s,_,p,_ = calibrate_train_alpenglow2(signal, p0,p1,p2,p3, 4)\n        feats[i,r1:r2,3] = s\n        \n        px = p.predict(np.arange(full_train.shape[1]))\n        if r2 > 283:\n            r2 = 283\n        for l in range(r1,r2):\n            signal = smooth_data(train[:,l], 330, 3)\n            \n            f = partial(f_coef, px[x_out], signal[x_out])\n            r = minimize_scalar(f)\n            a = r.x\n            score_a = r.fun\n    \n            f = partial(f_coef, px[x_in], signal[x_in])\n            r = minimize_scalar(f)\n            b = r.x\n            score_b = r.fun\n    \n            feats[i,l,8] = (1.0 - a / b)\n\n    ranges = [(0,1),(1,16),(16,31),(31,46),(46,62),(62,77),(77,97),(97,112),(112,133),(133,149),(149,168),\n              (168,185),(185,200),(200,215),(215,240),(240,255),(255,283)]\n    for r1,r2 in ranges:\n        signal = train[:,r1:r2].mean(axis=1)\n        signal = smooth_data(signal, 330, 3) \n        s,_,_,_ = calibrate_train_alpenglow2(signal, p0,p1,p2,p3, 3)\n        feats[i,r1:r2,4] = s\n        \n    ranges = [(j*8,8+j*8) for j in range(283//8+1)]\n    for r1,r2 in ranges:\n        signal = train[:,r1:r2].mean(axis=1)\n        signal = smooth_data(signal, 330, 3) \n        s,_,_,_ = calibrate_train_alpenglow2(signal, p0,p1,p2,p3, 3)\n        feats[i,r1:r2,5] = s\n\n    ranges = [(j*13,13+j*13) for j in range(283//13+1)]\n    for r1,r2 in ranges:\n        signal = train[:,r1:r2].mean(axis=1)\n        signal = smooth_data(signal, 330, 3) \n        s,_,_,_ = calibrate_train_alpenglow2(signal, p0,p1,p2,p3, 3)\n        feats[i,r1:r2,9] = s\n\n    feats[i,:,10] = (train[x_out].mean(axis=0) - train[x_out].mean()) / train[x_out].mean()\n\n    q_train = smooth_data(train.transpose(1,0), 330, 3)\n    q_train = q_train / q_train.mean(axis=1, keepdims=True)\n    \n    signal = q_train.mean(axis=0)\n    s,_,p,_ = calibrate_train_alpenglow2(signal, p0,p1,p2,p3, max_degs[i])\n    \n    px = p.predict(np.arange(full_train.shape[1]))\n\n    for l in range(283):\n        signal = q_train[l]\n\n        f = partial(f_coef, px[x_out], signal[x_out])\n        r = minimize_scalar(f)\n        a = r.x\n        score_a = r.fun\n\n        f = partial(f_coef, px[x_in], signal[x_in])\n        r = minimize_scalar(f)\n        b = r.x\n        score_b = r.fun\n\n        feats[i,l,6] = (1.0 - a / b)","metadata":{"execution":{"iopub.status.busy":"2024-08-29T08:21:59.927547Z","iopub.execute_input":"2024-08-29T08:21:59.927924Z","iopub.status.idle":"2024-08-29T08:22:00.138352Z","shell.execute_reply.started":"2024-08-29T08:21:59.927884Z","shell.execute_reply":"2024-08-29T08:22:00.13684Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"cnn_train = feats.transpose(0,2,1).copy()\ncnn_train[:,:10] = (cnn_train[:,:10] - 0.0025)*1e3","metadata":{},"outputs":[],"execution_count":null},{"cell_type":"code","source":"import torch\nimport torch.nn as nn\nimport torch.nn.functional as F\n\nclass CustomCNN(nn.Module):\n    def __init__(self):\n        super(CustomCNN, self).__init__()\n        \n        self.spectra = nn.Sequential(\n            nn.Conv1d(11, 256, 3, padding='same', bias=False),\n            nn.ReLU(),\n            nn.Conv1d(256, 256, 5, padding='same', bias=False),\n            nn.ReLU(),\n            nn.Conv1d(256, 256, 7, padding='same', bias=False),\n            nn.ReLU(),\n            nn.Conv1d(256, 256, 9, padding='same', bias=False),\n            nn.ReLU(),\n            nn.Conv1d(256, 256, 11, padding='same', bias=False),\n            nn.ReLU(),\n            nn.Conv1d(256, 256, 13, padding='same', bias=False),\n            nn.ReLU(),\n            nn.Conv1d(256, 1, 1, padding='same', bias=False),\n        )\n        \n        self.spectra200 = nn.Sequential(\n            nn.Conv1d(11, 256, 3, padding='same', bias=False),\n            nn.ReLU(),\n            nn.Conv1d(256, 256, 5, padding='same', bias=False),\n            nn.ReLU(),\n            nn.Conv1d(256, 256, 7, padding='same', bias=False),\n            nn.ReLU(),\n            nn.Conv1d(256, 256, 9, padding='same', bias=False),\n            nn.ReLU(),\n            nn.Conv1d(256, 256, 11, padding='same', bias=False),\n            nn.ReLU(),\n            nn.Conv1d(256, 256, 13, padding='same', bias=False),\n            nn.ReLU(),\n            nn.Conv1d(256, 1, 1, padding='same', bias=False),\n        )\n        \n        self.sigma = nn.Sequential(\n            nn.Conv1d(1, 32, kernel_size=3, bias=False),\n            nn.ReLU(),\n            nn.MaxPool1d(kernel_size=2, stride=2),\n            nn.Conv1d(32, 64, kernel_size=3, bias=False),\n            nn.ReLU(),\n            nn.MaxPool1d(kernel_size=2, stride=2),\n            nn.Conv1d(64, 128, kernel_size=3, bias=False),\n            nn.ReLU(),\n            nn.MaxPool1d(kernel_size=2, stride=2),\n            nn.Flatten()\n        )\n        \n        # Вычисляем размер выхода после сверток и пулинга\n        self._to_linear = None\n        self._get_conv_output((1, 283))\n        \n        # Полносвязные слои\n        self.sigma_out = nn.Linear(self._to_linear, 1)\n        \n    def _get_conv_output(self, shape):\n        batch_size = 1\n        input = torch.autograd.Variable(torch.rand(batch_size, *shape))\n        output = self.sigma(input)\n        self._to_linear = int(torch.numel(output) / batch_size)\n    \n    def forward(self, x_in):\n        \n        x1 = self.spectra(x_in[:,:11,:221])\n        x2 = self.spectra200(x_in[:,:11,200-21:])\n        x = torch.cat([x1[:,:,:200],x2[:,:,-83:]], dim=-1)\n        spectrum = torch.flatten(x, start_dim=1)\n        #y = torch.cat([x_in[:,7:], x-x_in[:,:1,:]], dim=1)\n        y = x-x_in[:,:1,:]\n        sigma = self.sigma_out(self.sigma(y))\n        \n        return spectrum, sigma","metadata":{},"outputs":[],"execution_count":null},{"cell_type":"code","source":"def create_mean_model():\n    model = CustomCNN()\n    return model\n\ntest_pred = np.zeros((len(cnn_train),283))\nmean_sigma = np.zeros_like(test_pred)\n\nval_x = torch.from_numpy(cnn_train).float()\nval_dataset = torch.utils.data.TensorDataset(val_x, val_x)\nvalidation_loader = torch.utils.data.DataLoader(val_dataset, batch_size=32, shuffle=False)\n\nfor i in range(5):\n    model = create_mean_model().cuda()\n    model.load_state_dict(torch.load(f'/kaggle/input/ariel-11-fts-pdf-crit/f11_wide_pdf_{i}'))\n    model.eval()\n    \n    v_offset = 0\n    with torch.no_grad():        \n        for i, vdata in enumerate(validation_loader):\n            vinputs, _ = vdata\n            voutputs, vsigma = model(vinputs.cuda())\n            test_pred[v_offset:v_offset+len(vinputs)] += voutputs.detach().cpu().numpy() * 0.2\n            mean_sigma[v_offset:v_offset+len(vinputs)] += vsigma.abs().detach().cpu().numpy() * 0.2\n            v_offset += len(vinputs)\n            \ntest_pred[~np.isfinite(test_pred)] = 0\ntest_pred = test_pred * 1e-3 + 0.0025\n\nmean_sigma[~np.isfinite(mean_sigma)] = 1.0\nmean_sigma = (mean_sigma * 1e-3) ** 0.5 * 1e-3\n\nsigma = mean_sigma.copy()\nsigma[test_pred.max(axis=1)-test_pred.min(axis=1) > 0.00018] += 2e-5\nsigma[test_pred.min(axis=1) < 1e-5] = 1e-2\n\npreds = test_pred.copy()\npreds[(test_pred[:,:250].max(axis=1) - test_pred[:,:250].min(axis=1)) < (test_pred[:,250:].max(axis=1) - test_pred[:,250:].min(axis=1)), 250:] = test_pred[(test_pred[:,:250].max(axis=1) - test_pred[:,:250].min(axis=1)) < (test_pred[:,250:].max(axis=1) - test_pred[:,250:].min(axis=1)), 250:251]\npreds[(test_pred[:,:200].max(axis=1) - test_pred[:,:200].min(axis=1)) < (test_pred[:,200:].max(axis=1) - test_pred[:,200:].min(axis=1)), 200:] = test_pred[(test_pred[:,:200].max(axis=1) - test_pred[:,:200].min(axis=1)) < (test_pred[:,200:].max(axis=1) - test_pred[:,200:].min(axis=1)), 200:201]\npreds[test_pred.max(axis=1)-test_pred.min(axis=1) < 0.0002] = smooth_data(preds[test_pred.max(axis=1)-test_pred.min(axis=1) < 0.0002], 100, 3)","metadata":{},"outputs":[],"execution_count":null},{"cell_type":"code","source":"ss = pd.read_csv('/kaggle/input/ariel-data-challenge-2024/sample_submission.csv')\n\nsubmission = pd.DataFrame(np.concatenate([preds.clip(0),\n                                          sigma.clip(1e-5)], axis=1), columns=ss.columns[1:])\nsubmission.index = test_adc_info.index\nsubmission.to_csv('submission.csv')","metadata":{"execution":{"iopub.status.busy":"2024-08-29T08:22:00.881888Z","iopub.execute_input":"2024-08-29T08:22:00.883016Z","iopub.status.idle":"2024-08-29T08:22:00.932482Z","shell.execute_reply.started":"2024-08-29T08:22:00.882969Z","shell.execute_reply":"2024-08-29T08:22:00.931215Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"plt.plot(preds[0])","metadata":{},"outputs":[],"execution_count":null},{"cell_type":"code","source":"submission","metadata":{"execution":{"iopub.status.busy":"2024-08-29T08:22:00.933978Z","iopub.execute_input":"2024-08-29T08:22:00.934465Z","iopub.status.idle":"2024-08-29T08:22:00.965046Z","shell.execute_reply.started":"2024-08-29T08:22:00.934431Z","shell.execute_reply":"2024-08-29T08:22:00.963905Z"},"trusted":true},"outputs":[],"execution_count":null}]}