{"nbformat":4,"nbformat_minor":0,"metadata":{"colab":{"provenance":[],"authorship_tag":"ABX9TyPukeIlNxcaSSqFoU581pfF"},"kernelspec":{"name":"python3","display_name":"Python 3"},"language_info":{"name":"python"}},"cells":[{"cell_type":"code","execution_count":76,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":74},"id":"U4sOFvt428H1","executionInfo":{"status":"ok","timestamp":1730556137977,"user_tz":-180,"elapsed":10267,"user":{"displayName":"Ahm 1","userId":"06653957866577488451"}},"outputId":"9bd7b9d5-a770-4e3f-c145-5fd540cfd6ff"},"outputs":[{"output_type":"display_data","data":{"text/plain":["<IPython.core.display.HTML object>"],"text/html":["\n","     <input type=\"file\" id=\"files-fec78491-9ecc-4453-817a-39c9ec2b495c\" name=\"files[]\" multiple disabled\n","        style=\"border:none\" />\n","     <output id=\"result-fec78491-9ecc-4453-817a-39c9ec2b495c\">\n","      Upload widget is only available when the cell has been executed in the\n","      current browser session. Please rerun this cell to enable.\n","      </output>\n","      <script>// Copyright 2017 Google LLC\n","//\n","// Licensed under the Apache License, Version 2.0 (the \"License\");\n","// you may not use this file except in compliance with the License.\n","// You may obtain a copy of the License at\n","//\n","//      http://www.apache.org/licenses/LICENSE-2.0\n","//\n","// Unless required by applicable law or agreed to in writing, software\n","// distributed under the License is distributed on an \"AS IS\" BASIS,\n","// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n","// See the License for the specific language governing permissions and\n","// limitations under the License.\n","\n","/**\n"," * @fileoverview Helpers for google.colab Python module.\n"," */\n","(function(scope) {\n","function span(text, styleAttributes = {}) {\n","  const element = document.createElement('span');\n","  element.textContent = text;\n","  for (const key of Object.keys(styleAttributes)) {\n","    element.style[key] = styleAttributes[key];\n","  }\n","  return element;\n","}\n","\n","// Max number of bytes which will be uploaded at a time.\n","const MAX_PAYLOAD_SIZE = 100 * 1024;\n","\n","function _uploadFiles(inputId, outputId) {\n","  const steps = uploadFilesStep(inputId, outputId);\n","  const outputElement = document.getElementById(outputId);\n","  // Cache steps on the outputElement to make it available for the next call\n","  // to uploadFilesContinue from Python.\n","  outputElement.steps = steps;\n","\n","  return _uploadFilesContinue(outputId);\n","}\n","\n","// This is roughly an async generator (not supported in the browser yet),\n","// where there are multiple asynchronous steps and the Python side is going\n","// to poll for completion of each step.\n","// This uses a Promise to block the python side on completion of each step,\n","// then passes the result of the previous step as the input to the next step.\n","function _uploadFilesContinue(outputId) {\n","  const outputElement = document.getElementById(outputId);\n","  const steps = outputElement.steps;\n","\n","  const next = steps.next(outputElement.lastPromiseValue);\n","  return Promise.resolve(next.value.promise).then((value) => {\n","    // Cache the last promise value to make it available to the next\n","    // step of the generator.\n","    outputElement.lastPromiseValue = value;\n","    return next.value.response;\n","  });\n","}\n","\n","/**\n"," * Generator function which is called between each async step of the upload\n"," * process.\n"," * @param {string} inputId Element ID of the input file picker element.\n"," * @param {string} outputId Element ID of the output display.\n"," * @return {!Iterable<!Object>} Iterable of next steps.\n"," */\n","function* uploadFilesStep(inputId, outputId) {\n","  const inputElement = document.getElementById(inputId);\n","  inputElement.disabled = false;\n","\n","  const outputElement = document.getElementById(outputId);\n","  outputElement.innerHTML = '';\n","\n","  const pickedPromise = new Promise((resolve) => {\n","    inputElement.addEventListener('change', (e) => {\n","      resolve(e.target.files);\n","    });\n","  });\n","\n","  const cancel = document.createElement('button');\n","  inputElement.parentElement.appendChild(cancel);\n","  cancel.textContent = 'Cancel upload';\n","  const cancelPromise = new Promise((resolve) => {\n","    cancel.onclick = () => {\n","      resolve(null);\n","    };\n","  });\n","\n","  // Wait for the user to pick the files.\n","  const files = yield {\n","    promise: Promise.race([pickedPromise, cancelPromise]),\n","    response: {\n","      action: 'starting',\n","    }\n","  };\n","\n","  cancel.remove();\n","\n","  // Disable the input element since further picks are not allowed.\n","  inputElement.disabled = true;\n","\n","  if (!files) {\n","    return {\n","      response: {\n","        action: 'complete',\n","      }\n","    };\n","  }\n","\n","  for (const file of files) {\n","    const li = document.createElement('li');\n","    li.append(span(file.name, {fontWeight: 'bold'}));\n","    li.append(span(\n","        `(${file.type || 'n/a'}) - ${file.size} bytes, ` +\n","        `last modified: ${\n","            file.lastModifiedDate ? file.lastModifiedDate.toLocaleDateString() :\n","                                    'n/a'} - `));\n","    const percent = span('0% done');\n","    li.appendChild(percent);\n","\n","    outputElement.appendChild(li);\n","\n","    const fileDataPromise = new Promise((resolve) => {\n","      const reader = new FileReader();\n","      reader.onload = (e) => {\n","        resolve(e.target.result);\n","      };\n","      reader.readAsArrayBuffer(file);\n","    });\n","    // Wait for the data to be ready.\n","    let fileData = yield {\n","      promise: fileDataPromise,\n","      response: {\n","        action: 'continue',\n","      }\n","    };\n","\n","    // Use a chunked sending to avoid message size limits. See b/62115660.\n","    let position = 0;\n","    do {\n","      const length = Math.min(fileData.byteLength - position, MAX_PAYLOAD_SIZE);\n","      const chunk = new Uint8Array(fileData, position, length);\n","      position += length;\n","\n","      const base64 = btoa(String.fromCharCode.apply(null, chunk));\n","      yield {\n","        response: {\n","          action: 'append',\n","          file: file.name,\n","          data: base64,\n","        },\n","      };\n","\n","      let percentDone = fileData.byteLength === 0 ?\n","          100 :\n","          Math.round((position / fileData.byteLength) * 100);\n","      percent.textContent = `${percentDone}% done`;\n","\n","    } while (position < fileData.byteLength);\n","  }\n","\n","  // All done.\n","  yield {\n","    response: {\n","      action: 'complete',\n","    }\n","  };\n","}\n","\n","scope.google = scope.google || {};\n","scope.google.colab = scope.google.colab || {};\n","scope.google.colab._files = {\n","  _uploadFiles,\n","  _uploadFilesContinue,\n","};\n","})(self);\n","</script> "]},"metadata":{}},{"output_type":"stream","name":"stdout","text":["Saving Titanic-Datasett.csv to Titanic-Datasett.csv\n"]}],"source":["import pandas as pd\n","import numpy as np\n","import seaborn as sns\n","import matplotlib.pyplot as plt\n","\n","# Code to upload file from your PC to Colab\n","from google.colab import files\n","uploaded = files.upload()  # This will open a file picker - select your Titanic-Dataset.csv\n","\n","# Load the dataset\n","df = pd.read_csv('Titanic-Datasett.csv')"]},{"cell_type":"code","source":["# Preview the first 5 rows\n","print(\"First 5 rows:\")\n","print(df.head())\n","\n","print(\"\\nFeature types:\")\n","print(df.dtypes)"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"9R6OJagX3sXA","executionInfo":{"status":"ok","timestamp":1730556144721,"user_tz":-180,"elapsed":310,"user":{"displayName":"Ahm 1","userId":"06653957866577488451"}},"outputId":"39d8cbb1-67e5-4d0e-8f34-4c6700578ea2"},"execution_count":77,"outputs":[{"output_type":"stream","name":"stdout","text":["First 5 rows:\n","   PassengerId  Survived  Pclass  \\\n","0            1         0       3   \n","1            2         1       1   \n","2            3         1       3   \n","3            4         1       1   \n","4            5         0       3   \n","\n","                                                Name     Sex   Age  SibSp  \\\n","0                            Braund, Mr. Owen Harris    male  22.0      1   \n","1  Cumings, Mrs. John Bradley (Florence Briggs Th...  female  38.0      1   \n","2                             Heikkinen, Miss. Laina  female  26.0      0   \n","3       Futrelle, Mrs. Jacques Heath (Lily May Peel)  female  35.0      1   \n","4                           Allen, Mr. William Henry    male  35.0      0   \n","\n","   Parch            Ticket     Fare Cabin Embarked  \n","0      0         A/5 21171   7.2500   NaN        S  \n","1      0          PC 17599  71.2833   C85        C  \n","2      0  STON/O2. 3101282   7.9250   NaN        S  \n","3      0            113803  53.1000  C123        S  \n","4      0            373450   8.0500   NaN        S  \n","\n","Feature types:\n","PassengerId      int64\n","Survived         int64\n","Pclass           int64\n","Name            object\n","Sex             object\n","Age            float64\n","SibSp            int64\n","Parch            int64\n","Ticket          object\n","Fare           float64\n","Cabin           object\n","Embarked        object\n","dtype: object\n"]}]},{"cell_type":"code","source":["# Get descriptive statistics\n","print(\"Descriptive statistics:\")\n","print(df.describe())"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"IYoqC3rnCH0X","executionInfo":{"status":"ok","timestamp":1730556148319,"user_tz":-180,"elapsed":328,"user":{"displayName":"Ahm 1","userId":"06653957866577488451"}},"outputId":"c885e2d2-ba37-4f6f-e13d-c606dbd214e0"},"execution_count":78,"outputs":[{"output_type":"stream","name":"stdout","text":["Descriptive statistics:\n","       PassengerId    Survived      Pclass         Age       SibSp  \\\n","count   891.000000  891.000000  891.000000  714.000000  891.000000   \n","mean    446.000000    0.383838    2.308642   29.699118    0.523008   \n","std     257.353842    0.486592    0.836071   14.526497    1.102743   \n","min       1.000000    0.000000    1.000000    0.420000    0.000000   \n","25%     223.500000    0.000000    2.000000   20.125000    0.000000   \n","50%     446.000000    0.000000    3.000000   28.000000    0.000000   \n","75%     668.500000    1.000000    3.000000   38.000000    1.000000   \n","max     891.000000    1.000000    3.000000   80.000000    8.000000   \n","\n","            Parch        Fare  \n","count  891.000000  891.000000  \n","mean     0.381594   32.204208  \n","std      0.806057   49.693429  \n","min      0.000000    0.000000  \n","25%      0.000000    7.910400  \n","50%      0.000000   14.454200  \n","75%      0.000000   31.000000  \n","max      6.000000  512.329200  \n"]}]},{"cell_type":"code","source":["# Get count of missing values\n","print(\"Missing values count:\")\n","print(df.isnull().sum())"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"6z5SmBBxCPMM","executionInfo":{"status":"ok","timestamp":1730556151488,"user_tz":-180,"elapsed":340,"user":{"displayName":"Ahm 1","userId":"06653957866577488451"}},"outputId":"7f445ba3-19ad-49f7-e4d5-d3e5fe49ff25"},"execution_count":79,"outputs":[{"output_type":"stream","name":"stdout","text":["Missing values count:\n","PassengerId      0\n","Survived         0\n","Pclass           0\n","Name             0\n","Sex              0\n","Age            177\n","SibSp            0\n","Parch            0\n","Ticket           0\n","Fare             0\n","Cabin          687\n","Embarked         2\n","dtype: int64\n"]}]},{"cell_type":"code","source":["# Calculate missing value percentages\n","missing_percentage = df.isnull().mean() * 100\n","threshold = 30\n","\n","# Filter columns with more than the threshold percentage of missing values\n","columns_to_drop = missing_percentage[missing_percentage > threshold].index\n","\n","# Drop the columns\n","df = df.drop(columns=columns_to_drop)\n","\n","# Display results\n","print(f\"Columns dropped: {list(columns_to_drop)}\")\n","print(f\"Remaining columns: {list(df.columns)}\")"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"R7GpmtGMCW4R","executionInfo":{"status":"ok","timestamp":1730556155999,"user_tz":-180,"elapsed":340,"user":{"displayName":"Ahm 1","userId":"06653957866577488451"}},"outputId":"d7060c25-1ec8-40d4-b51e-839e5f1903f1"},"execution_count":80,"outputs":[{"output_type":"stream","name":"stdout","text":["Columns dropped: ['Cabin']\n","Remaining columns: ['PassengerId', 'Survived', 'Pclass', 'Name', 'Sex', 'Age', 'SibSp', 'Parch', 'Ticket', 'Fare', 'Embarked']\n"]}]},{"cell_type":"code","source":["from sklearn.preprocessing import LabelEncoder\n","\n","# Label encode categorical variables\n","label_encoder = LabelEncoder()\n","for column in df.select_dtypes(include=['object']).columns:\n","    df[column] = label_encoder.fit_transform(df[column])\n","\n","print(\"Data after label encoding:\")\n","print(df.head())"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"X2FzHF_ICmz9","executionInfo":{"status":"ok","timestamp":1730556158883,"user_tz":-180,"elapsed":371,"user":{"displayName":"Ahm 1","userId":"06653957866577488451"}},"outputId":"ff1bd6f9-65a6-47c3-ee7c-c99261db67c5"},"execution_count":81,"outputs":[{"output_type":"stream","name":"stdout","text":["Data after label encoding:\n","   PassengerId  Survived  Pclass  Name  Sex   Age  SibSp  Parch  Ticket  \\\n","0            1         0       3   108    1  22.0      1      0     523   \n","1            2         1       1   190    0  38.0      1      0     596   \n","2            3         1       3   353    0  26.0      0      0     669   \n","3            4         1       1   272    0  35.0      1      0      49   \n","4            5         0       3    15    1  35.0      0      0     472   \n","\n","      Fare  Embarked  \n","0   7.2500         2  \n","1  71.2833         0  \n","2   7.9250         2  \n","3  53.1000         2  \n","4   8.0500         2  \n"]}]},{"cell_type":"code","source":["# Fill missing values in numerical columns with mean\n","for column in df.select_dtypes(include=['float64', 'int64']).columns:\n","    mean_value = df[column].mean()\n","    df[column] = df[column].fillna(mean_value)\n","\n","# Fill missing values in categorical columns with mode\n","for column in df.select_dtypes(include=['object']).columns:\n","    mode_value = df[column].mode()[0]\n","    df[column] = df[column].fillna(mode_value)\n","\n","# Check remaining missing values\n","print(\"Missing values after filling:\")\n","print(df.isnull().sum())"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"WqNT3q7VCzaB","executionInfo":{"status":"ok","timestamp":1730556161947,"user_tz":-180,"elapsed":412,"user":{"displayName":"Ahm 1","userId":"06653957866577488451"}},"outputId":"8ed552a4-fdec-40d7-f222-51eb23eac4ae"},"execution_count":82,"outputs":[{"output_type":"stream","name":"stdout","text":["Missing values after filling:\n","PassengerId    0\n","Survived       0\n","Pclass         0\n","Name           0\n","Sex            0\n","Age            0\n","SibSp          0\n","Parch          0\n","Ticket         0\n","Fare           0\n","Embarked       0\n","dtype: int64\n"]}]},{"cell_type":"code","source":["def replace_outliers_with_nan(column):\n","    Q1 = column.quantile(0.25)\n","    Q3 = column.quantile(0.75)\n","    IQR = Q3 - Q1\n","    lower_bound = Q1 - 1.5 * IQR\n","    upper_bound = Q3 + 1.5 * IQR\n","    return column.where((column >= lower_bound) & (column <= upper_bound), np.nan)\n","\n","# Replace outliers with NaN for each numeric feature\n","for col in df.select_dtypes(include=['float64', 'int64']).columns:\n","    df[col] = replace_outliers_with_nan(df[col])\n","\n","print(\"Null values after outlier detection:\")\n","print(df.isnull().sum())"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"iVjAbHOeC5TJ","executionInfo":{"status":"ok","timestamp":1730556165625,"user_tz":-180,"elapsed":412,"user":{"displayName":"Ahm 1","userId":"06653957866577488451"}},"outputId":"6142499d-01e1-40ba-962b-39041dd15a41"},"execution_count":83,"outputs":[{"output_type":"stream","name":"stdout","text":["Null values after outlier detection:\n","PassengerId      0\n","Survived         0\n","Pclass           0\n","Name             0\n","Sex              0\n","Age             66\n","SibSp           46\n","Parch          213\n","Ticket           0\n","Fare           116\n","Embarked         0\n","dtype: int64\n"]}]},{"cell_type":"code","source":["# Distribution of Age\n","plt.figure(figsize=(8, 6))\n","sns.histplot(df['Age'], bins=15, kde=True, color='blue')\n","plt.title('Age Distribution')\n","plt.xlabel('Age')\n","plt.ylabel('Frequency')\n","plt.show()"],"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":564},"id":"yqdfU20YC_hI","executionInfo":{"status":"ok","timestamp":1730556169764,"user_tz":-180,"elapsed":450,"user":{"displayName":"Ahm 1","userId":"06653957866577488451"}},"outputId":"d9c95340-7f4d-425d-affb-188ee1db0a53"},"execution_count":84,"outputs":[{"output_type":"display_data","data":{"text/plain":["<Figure size 800x600 with 1 Axes>"],"image/png":"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\n"},"metadata":{}}]},{"cell_type":"code","source":["# Survival Count\n","plt.figure(figsize=(8, 6))\n","sns.countplot(x='Survived', data=df, palette='Set2')\n","plt.title('Survival Count')\n","plt.xlabel('Survived')\n","plt.ylabel('Count')\n","plt.show()"],"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":673},"id":"bosgT1uiDDd0","executionInfo":{"status":"ok","timestamp":1730556175265,"user_tz":-180,"elapsed":333,"user":{"displayName":"Ahm 1","userId":"06653957866577488451"}},"outputId":"07f0b080-2b89-4dd3-ea22-cf00f8b7f4cc"},"execution_count":85,"outputs":[{"output_type":"stream","name":"stderr","text":["<ipython-input-85-8eed7ab37b0a>:3: FutureWarning: \n","\n","Passing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `x` variable to `hue` and set `legend=False` for the same effect.\n","\n","  sns.countplot(x='Survived', data=df, palette='Set2')\n"]},{"output_type":"display_data","data":{"text/plain":["<Figure size 800x600 with 1 Axes>"],"image/png":"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\n"},"metadata":{}}]},{"cell_type":"code","source":["# Age vs Fare\n","plt.figure(figsize=(8, 6))\n","sns.scatterplot(x='Age', y='Fare', data=df, hue='Survived', palette='Set1')\n","plt.title('Age vs Fare')\n","plt.xlabel('Age')\n","plt.ylabel('Fare')\n","plt.show()"],"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":564},"id":"Gomv9YdIDQev","executionInfo":{"status":"ok","timestamp":1730556179585,"user_tz":-180,"elapsed":632,"user":{"displayName":"Ahm 1","userId":"06653957866577488451"}},"outputId":"507b2f44-a7a1-408c-b9c0-1572acfcc810"},"execution_count":86,"outputs":[{"output_type":"display_data","data":{"text/plain":["<Figure size 800x600 with 1 Axes>"],"image/png":"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\n"},"metadata":{}}]},{"cell_type":"code","source":["# Survival by Passenger Class\n","plt.figure(figsize=(8, 6))\n","sns.boxplot(x='Pclass', y='Age', data=df, palette='Set1')\n","plt.title('Age Distribution by Passenger Class')\n","plt.xlabel('Passenger Class')\n","plt.ylabel('Age')\n","plt.show()"],"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":673},"id":"_LFNg4hSDVMw","executionInfo":{"status":"ok","timestamp":1730556183939,"user_tz":-180,"elapsed":406,"user":{"displayName":"Ahm 1","userId":"06653957866577488451"}},"outputId":"57b00c8e-1019-4617-fe13-725d29197f9f"},"execution_count":87,"outputs":[{"output_type":"stream","name":"stderr","text":["<ipython-input-87-6354a43d7eda>:3: FutureWarning: \n","\n","Passing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `x` variable to `hue` and set `legend=False` for the same effect.\n","\n","  sns.boxplot(x='Pclass', y='Age', data=df, palette='Set1')\n"]},{"output_type":"display_data","data":{"text/plain":["<Figure size 800x600 with 1 Axes>"],"image/png":"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\n"},"metadata":{}}]},{"cell_type":"code","source":[],"metadata":{"id":"gzSlI6_rDh4_"},"execution_count":null,"outputs":[]}]}