├── Data_Analysis └── Diwali Sales │ ├── Diwali_Sales_Analysis.ipynb │ ├── Diwali_Sales_Data - Diwali Sales Data.csv │ └── HarryPotter.py ├── README.md ├── data_manipulation ├── Data_Manupulation.ipynb ├── average_salary_by_department.py ├── dataframe_basics │ ├── notebook2.ipynb │ └── weather_data.csv └── messi.py ├── data_visualization ├── Basic_Line_plot.py ├── Box_plots.py ├── Grouped_Bar_plots.py ├── Heatmap.py ├── Housing_Price_Prediction.py ├── line chart.py └── pie_chart.py ├── deep_learning └── mnist_cnn_classifier.py ├── machine_learning ├── PCA_2D_to_1D.ipynb ├── knn_classifier_iris.py ├── lowest_ranked_movies │ ├── decision_tree_regressor.py │ └── movies.csv └── naive_bayes.py └── miscellaneous └── file_handling_logging.py /Data_Analysis/Diwali Sales/HarryPotter.py: -------------------------------------------------------------------------------- 1 | 2 | import pandas as pd 3 | import matplotlib.pyplot as plt 4 | 5 | data = { 6 | 'name': ['Harry', 'Hermione', 'Ron', 'Draco', 'Luna', 'Neville', 'Cedric', 'Cho'], 7 | 'house': ['Gryffindor', 'Gryffindor', 'Gryffindor', 'Slytherin', 'Ravenclaw', 'Gryffindor', 'Hufflepuff', 'Ravenclaw'], 8 | 'age': [17, 17, 17, 17, 16, 17, 18, 17], 9 | 'wand_length': [11, 10.75, 14, 10, 13.5, 13, 12.25, 11] 10 | } 11 | df = pd.DataFrame(data) 12 | 13 | 14 | print("Harry Potter Characters Dataset:") 15 | print(df) 16 | 17 | house_counts = df['house'].value_counts() 18 | print("\nNumber of characters in each house:") 19 | print(house_counts) 20 | 21 | 22 | plt.figure(figsize=(6, 4)) 23 | house_counts.plot(kind='bar', color=['red', 'green', 'blue', 'yellow']) 24 | plt.title('Character Distribution by House') 25 | plt.xlabel('House') 26 | plt.ylabel('Number of Characters') 27 | plt.show() 28 | 29 | 30 | avg_wand_length = df['wand_length'].mean() 31 | print("\nAverage wand length:", avg_wand_length) 32 | 33 | gryffindor_students = df[df['house'] == 'Gryffindor'] 34 | print("\nGryffindor Students:") 35 | print(gryffindor_students) 36 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Data-Science-Snippets 2 | 3 | Welcome to **Data-Science-Snippets**! 🎉 This repository is a collection of handy code snippets and mini-scripts designed to help data scientists, researchers, and enthusiasts with various data science tasks. Whether you're manipulating data, building visualizations, or exploring machine learning algorithms, this repository has you covered! 4 | 5 | ### 🚀 What's Inside? 6 | - **Data Manipulation**: Pandas, Numpy operations, and data cleaning tips. 7 | - **Visualization**: Matplotlib, Seaborn, and Plotly snippets for insightful charts and plots. 8 | - **Machine Learning**: Model building, evaluation, and tuning with Scikit-Learn and more. 9 | - **Data Preprocessing**: Handling missing values, feature engineering, and scaling. 10 | - **Deep Learning**: Neural network architectures and training tips using TensorFlow/Keras. 11 | - **Miscellaneous**: Utility functions and scripts for file handling, logging, and automation. 12 | 13 | --- 14 | 15 | ## 🎃 Hacktoberfest 2024 Collaboration 16 | We are thrilled to announce that **Data-Science-Snippets** is part of **Hacktoberfest 2024**! Hacktoberfest is a month-long celebration of open-source software, and we welcome all contributors, from beginners to seasoned developers, to join us and help make this repository even better. 17 | 18 | ### 🛠 How to Contribute? 19 | We are actively looking for contributions, be it bug fixes, enhancements, or new snippets! Follow the steps below to get started: 20 | 21 | 1. **Fork the Repository** 22 | Click the "Fork" button at the top right of this page to create your own copy of the repository. 23 | 24 | 2. **Clone the Repository** 25 | Clone the forked repository to your local machine: 26 | ```bash 27 | git clone https://github.com/your-username/Data-Science-Snippets.git 28 | ``` 29 | 3. **Create a New Branch** 30 | Create a new branch for your feature or bug fix: 31 | ```bash 32 | git checkout -b feature/your-feature-name 33 | ``` 34 | 4. **Make Your Changes** 35 | 36 | Add your code snippets, scripts, or modifications to the relevant folder. Please follow the Guidelines for naming conventions and structure. 37 | 5. **Commit and Push** 38 | Commit your changes with a descriptive message: 39 | ``` 40 | git commit -m "Added new snippet for data preprocessing using pandas" 41 | ``` 42 | Push the changes to your fork: 43 | ``` 44 | git push origin feature/your-feature-name 45 | ``` 46 | 6. **Submit a Pull Request** 47 | 48 | Go to the original repository and click on the "New Pull Request" button. Provide a brief description of your changes and submit your pull request! 49 | 50 | 7. **Wait for Review** 51 | 52 | One of the maintainers will review your pull request and provide feedback or merge it into the main branch. 53 | 54 | ## 📜 Contribution Guidelines 55 | To maintain the quality and consistency of this repository, please follow these guidelines when contributing: 56 | 57 | ### File Naming 58 | - Use descriptive names for your scripts, e.g., `data_cleaning_with_pandas.py` or `linear_regression_sklearn.py`. 59 | - Follow the `snake_case` naming convention for files and folders. 60 | 61 | ### Code Documentation 62 | - Include comments to describe the functionality of your code. 63 | - For complex functions or classes, provide a docstring explaining the parameters and return values. 64 | 65 | ### Folder Structure 66 | Place your snippets in the appropriate folder, or create a new one if necessary. The folder structure is as follows: 67 | 68 | ``` 69 | ├── data_manipulation/ 70 | ├── data_visualization/ 71 | ├── machine_learning/ 72 | ├── deep_learning/ 73 | └── miscellaneous/ 74 | ``` 75 | 76 | 77 | ### Code Style 78 | Follow the [PEP 8 style guide](https://www.python.org/dev/peps/pep-0008?wt.mc_id=studentamb_296415) for Python code. This includes using meaningful variable names, adhering to indentation standards, and maintaining readability. 79 | 80 | ### Testing 81 | Test your snippets with sample data to ensure they work as expected. Include sample data or instructions on how to generate it if necessary. 82 | 83 | ### README Update 84 | If you add a new category or a significant snippet, update the main `README.md` with a brief description and relevant usage examples. 85 | 86 | ## 📢 Important Note 87 | All contributions must abide by the [Hacktoberfest Rules](https://hacktoberfest.com/participation?wt.mc_id=studentamb_296415) to be considered valid. This includes submitting meaningful pull requests that add value to the project. 88 | 89 | ## 📚 Resources 90 | If you're new to open-source or want to learn more about contributing, check out these resources: 91 | - [How to Contribute to Open Source](https://opensource.guide/how-to-contribute?wt.mc_id=studentamb_296415) 92 | - [GitHub Documentation](https://docs.github.com?wt.mc_id=studentamb_296415) 93 | - [Hacktoberfest Participation Guide](https://hacktoberfest.com/participation?wt.mc_id=studentamb_296415) 94 | 95 | ## 💬 Contact and Community 96 | Join our [Discord community](#) to discuss ideas, ask questions, or get help with your contributions. You can also connect with us on [Twitter](#) or [LinkedIn](https://www.linkedin.com/company/mlsa-nexus?wt.mc_id=studentamb_296415). 97 | 98 | Let's build something amazing together! Happy coding! 💻✨ 99 | -------------------------------------------------------------------------------- /data_manipulation/Data_Manupulation.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "nbformat": 4, 3 | "nbformat_minor": 0, 4 | "metadata": { 5 | "colab": { 6 | "provenance": [] 7 | }, 8 | "kernelspec": { 9 | "name": "python3", 10 | "display_name": "Python 3" 11 | }, 12 | "language_info": { 13 | "name": "python" 14 | } 15 | }, 16 | "cells": [ 17 | { 18 | "cell_type": "markdown", 19 | "source": [ 20 | "#Data_Manupulation\n", 21 | "## Project By: Aditya Ghosh\n", 22 | "[Linkedin](https://www.linkedin.com/in/adityaghosh2992/) [Github](https://github.com/aditya-ghosh2992)\n", 23 | "\n", 24 | "[link text](https://)" 25 | ], 26 | "metadata": { 27 | "id": "BBblYYilWJnV" 28 | } 29 | }, 30 | { 31 | "cell_type": "markdown", 32 | "source": [ 33 | "#Key feature of Data Manipulation :\n", 34 | "\n", 35 | "* Data Cleaning: Handle missing values, outliers, and inconsistencies.\n", 36 | "* Data Transformation: Convert raw data into a suitable format for analysis.\n", 37 | "* Data Aggregation: Group and summarize data to identify trends and patterns.\n", 38 | "* Data Visualization: Create informative charts and graphs to communicate insights.\n", 39 | "\n", 40 | "\n" 41 | ], 42 | "metadata": { 43 | "id": "zXzAukgVW-wM" 44 | } 45 | }, 46 | { 47 | "cell_type": "code", 48 | "source": [ 49 | "import pandas as pd\n", 50 | "import matplotlib.pyplot as plt\n", 51 | "\n", 52 | "# Sample data\n", 53 | "data = [\n", 54 | " {'date': '2023-11-25', 'amount': -50, 'category': 'Food', 'description': 'Dinner'},\n", 55 | " {'date': '2023-11-26', 'amount': 1000, 'category': 'Income', 'description': 'Salary'},\n", 56 | " {'date': '2023-11-27', 'amount': -20, 'category': 'Transportation', 'description': 'Bus Fare'},\n", 57 | " {'date': '2023-11-28', 'amount': -100, 'category': 'Shopping', 'description': 'Clothes'},\n", 58 | " {'date': '2023-11-29', 'amount': -30, 'category': 'Entertainment', 'description': 'Movie Ticket'},\n", 59 | " {'date': '2023-11-30', 'amount': -40, 'category': 'Food', 'description': 'Lunch'},\n", 60 | " {'date': '2023-12-01', 'amount': 800, 'category': 'Income', 'description': 'Freelance Work'},\n", 61 | " {'date': '2023-12-02', 'amount': -50, 'category': 'Food', 'description': 'Dinner'},\n", 62 | " {'date': '2023-12-03', 'amount': -25, 'category': 'Utilities', 'description': 'Electricity Bill'},\n", 63 | " {'date': '2023-12-04', 'amount': -35, 'category': 'Entertainment', 'description': 'Concert Ticket'}\n", 64 | "]\n", 65 | "\n", 66 | "# Create a Pandas DataFrame\n", 67 | "df = pd.DataFrame(data)\n", 68 | "\n", 69 | "# Filter transactions by date range\n", 70 | "start_date = '2023-11-25'\n", 71 | "end_date = '2023-12-04'\n", 72 | "filtered_df = df[(df['date'] >= start_date) & (df['date'] <= end_date)]\n", 73 | "\n", 74 | "# Group transactions by category and calculate total spending\n", 75 | "category_spending = filtered_df.groupby('category')['amount'].sum()\n", 76 | "\n", 77 | "# Visualize spending by category\n", 78 | "category_spending.plot(kind='bar')\n", 79 | "plt.title('Spending by Category')\n", 80 | "plt.xlabel('Category')\n", 81 | "plt.ylabel('Amount')\n", 82 | "plt.show()\n", 83 | "\n", 84 | "# Calculate monthly spending\n", 85 | "df['month'] = pd.to_datetime(df['date']).dt.to_period('M')\n", 86 | "monthly_spending = df.groupby('month')['amount'].sum()\n", 87 | "\n", 88 | "# Visualize monthly spending over time\n", 89 | "monthly_spending.plot(kind='line')\n", 90 | "plt.title('Monthly Spending')\n", 91 | "plt.xlabel('Month')\n", 92 | "plt.ylabel('Amount')\n", 93 | "plt.show()" 94 | ], 95 | "metadata": { 96 | "colab": { 97 | "base_uri": "https://localhost:8080/", 98 | "height": 1000 99 | }, 100 | "id": "WhAFkFZKPINi", 101 | "outputId": "e9aaf7f4-6c44-40cd-c759-7823775be5ff" 102 | }, 103 | "execution_count": 1, 104 | "outputs": [ 105 | { 106 | "output_type": "display_data", 107 | "data": { 108 | "text/plain": [ 109 | "
" 110 | ], 111 | "image/png": "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\n" 112 | }, 113 | "metadata": {} 114 | }, 115 | { 116 | "output_type": "display_data", 117 | "data": { 118 | "text/plain": [ 119 | "
" 120 | ], 121 | "image/png": "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\n" 122 | }, 123 | "metadata": {} 124 | } 125 | ] 126 | } 127 | ] 128 | } -------------------------------------------------------------------------------- /data_manipulation/average_salary_by_department.py: -------------------------------------------------------------------------------- 1 | import pandas as pd 2 | 3 | # Sample data 4 | data = { 5 | 'Name': ['Alice', 'Bob', 'Charlie', 'David', 'Emma'], 6 | 'Department': ['Sales', 'HR', 'Sales', 'IT', 'HR'], 7 | 'Salary': [60000, 50000, 70000, 65000, 52000] 8 | } 9 | 10 | # Create a DataFrame 11 | df = pd.DataFrame(data) 12 | 13 | # Data manipulation: Group by 'Department' and calculate average salary 14 | avg_salary_by_dept = df.groupby('Department')['Salary'].mean().reset_index() 15 | 16 | # Sort the result by average salary in descending order 17 | avg_salary_by_dept = avg_salary_by_dept.sort_values(by='Salary', ascending=False) 18 | 19 | print("Average Salary by Department:") 20 | print(avg_salary_by_dept) 21 | -------------------------------------------------------------------------------- /data_manipulation/dataframe_basics/notebook2.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 1, 6 | "metadata": {}, 7 | "outputs": [ 8 | { 9 | "name": "stdout", 10 | "output_type": "stream", 11 | "text": [ 12 | " day Temperature\n", 13 | "0 1/1/2017 32\n", 14 | "1 1/2/2017 35\n", 15 | "2 1/3/2017 28\n", 16 | "3 1/4/2017 24\n", 17 | "4 1/5/2017 32\n", 18 | "5 1/6/2017 31\n" 19 | ] 20 | } 21 | ], 22 | "source": [ 23 | "#dataframe basics\n", 24 | "\n", 25 | "import pandas as pd\n", 26 | "\n", 27 | "#dictionary to dataframe\n", 28 | "d1 = {'day': ['1/1/2017', '1/2/2017', '1/3/2017', '1/4/2017', '1/5/2017', '1/6/2017'], 'Temperature': [32,35,28,24,32,31]}\n", 29 | "\n", 30 | "df2 = pd.DataFrame(d1)\n", 31 | "print(df2)" 32 | ] 33 | }, 34 | { 35 | "cell_type": "code", 36 | "execution_count": 2, 37 | "metadata": {}, 38 | "outputs": [ 39 | { 40 | "name": "stdout", 41 | "output_type": "stream", 42 | "text": [ 43 | " day temperature windspeed event\n", 44 | "0 1/1/2017 32 6 Rain\n", 45 | "1 1/2/2017 35 7 Sunny\n", 46 | "2 1/3/2017 28 2 Snow\n", 47 | "3 1/4/2017 24 7 Snow\n", 48 | "4 1/5/2017 32 4 Rain\n", 49 | "5 1/6/2017 31 2 Sunny\n" 50 | ] 51 | } 52 | ], 53 | "source": [ 54 | "df = pd.read_csv('weather_data.csv')\n", 55 | "print(df)\n" 56 | ] 57 | }, 58 | { 59 | "cell_type": "code", 60 | "execution_count": 3, 61 | "metadata": {}, 62 | "outputs": [ 63 | { 64 | "name": "stdout", 65 | "output_type": "stream", 66 | "text": [ 67 | "6\n", 68 | "4\n" 69 | ] 70 | } 71 | ], 72 | "source": [ 73 | "rows, column = df.shape #return a tuple of rows and column\n", 74 | "print(rows)\n", 75 | "print(column)" 76 | ] 77 | }, 78 | { 79 | "cell_type": "code", 80 | "execution_count": 4, 81 | "metadata": {}, 82 | "outputs": [ 83 | { 84 | "name": "stdout", 85 | "output_type": "stream", 86 | "text": [ 87 | " day temperature windspeed event\n", 88 | "0 1/1/2017 32 6 Rain\n", 89 | "1 1/2/2017 35 7 Sunny\n", 90 | "2 1/3/2017 28 2 Snow\n", 91 | "3 1/4/2017 24 7 Snow\n", 92 | "4 1/5/2017 32 4 Rain\n", 93 | " day temperature windspeed event\n", 94 | "0 1/1/2017 32 6 Rain\n", 95 | "1 1/2/2017 35 7 Sunny\n", 96 | "2 1/3/2017 28 2 Snow\n" 97 | ] 98 | } 99 | ], 100 | "source": [ 101 | "print(df.head())\n", 102 | "print(df.head(3)) #print first 3 rows" 103 | ] 104 | }, 105 | { 106 | "cell_type": "code", 107 | "execution_count": 5, 108 | "metadata": {}, 109 | "outputs": [ 110 | { 111 | "name": "stdout", 112 | "output_type": "stream", 113 | "text": [ 114 | " day temperature windspeed event\n", 115 | "1 1/2/2017 35 7 Sunny\n", 116 | "2 1/3/2017 28 2 Snow\n", 117 | "3 1/4/2017 24 7 Snow\n", 118 | "4 1/5/2017 32 4 Rain\n", 119 | "5 1/6/2017 31 2 Sunny\n", 120 | " day temperature windspeed event\n", 121 | "4 1/5/2017 32 4 Rain\n", 122 | "5 1/6/2017 31 2 Sunny\n" 123 | ] 124 | } 125 | ], 126 | "source": [ 127 | "print(df.tail())\n", 128 | "print(df.tail(2)) # print last two rows" 129 | ] 130 | }, 131 | { 132 | "cell_type": "code", 133 | "execution_count": 6, 134 | "metadata": {}, 135 | "outputs": [ 136 | { 137 | "name": "stdout", 138 | "output_type": "stream", 139 | "text": [ 140 | " day temperature windspeed event\n", 141 | "2 1/3/2017 28 2 Snow\n", 142 | "3 1/4/2017 24 7 Snow\n", 143 | "4 1/5/2017 32 4 Rain\n", 144 | "\n", 145 | " day temperature windspeed event\n", 146 | "0 1/1/2017 32 6 Rain\n", 147 | "2 1/3/2017 28 2 Snow\n", 148 | "4 1/5/2017 32 4 Rain\n" 149 | ] 150 | } 151 | ], 152 | "source": [ 153 | "#datafram slicing\n", 154 | "\n", 155 | "print(df[2:5]) #print rows from 2 to 4\n", 156 | "print()\n", 157 | "print(df[::2]) #print rows from 0 to end with step 2 " 158 | ] 159 | }, 160 | { 161 | "cell_type": "code", 162 | "execution_count": 7, 163 | "metadata": {}, 164 | "outputs": [ 165 | { 166 | "data": { 167 | "text/plain": [ 168 | "Index(['day', 'temperature', 'windspeed', 'event'], dtype='object')" 169 | ] 170 | }, 171 | "execution_count": 7, 172 | "metadata": {}, 173 | "output_type": "execute_result" 174 | } 175 | ], 176 | "source": [ 177 | "df.columns #print columns" 178 | ] 179 | }, 180 | { 181 | "cell_type": "code", 182 | "execution_count": 8, 183 | "metadata": {}, 184 | "outputs": [ 185 | { 186 | "data": { 187 | "text/plain": [ 188 | "0 1/1/2017\n", 189 | "1 1/2/2017\n", 190 | "2 1/3/2017\n", 191 | "3 1/4/2017\n", 192 | "4 1/5/2017\n", 193 | "5 1/6/2017\n", 194 | "Name: day, dtype: object" 195 | ] 196 | }, 197 | "execution_count": 8, 198 | "metadata": {}, 199 | "output_type": "execute_result" 200 | } 201 | ], 202 | "source": [ 203 | "df.day #print individual columns by their name" 204 | ] 205 | }, 206 | { 207 | "cell_type": "code", 208 | "execution_count": 9, 209 | "metadata": {}, 210 | "outputs": [ 211 | { 212 | "data": { 213 | "text/plain": [ 214 | "pandas.core.frame.DataFrame" 215 | ] 216 | }, 217 | "execution_count": 9, 218 | "metadata": {}, 219 | "output_type": "execute_result" 220 | } 221 | ], 222 | "source": [ 223 | "type(df)" 224 | ] 225 | }, 226 | { 227 | "cell_type": "code", 228 | "execution_count": 10, 229 | "metadata": {}, 230 | "outputs": [ 231 | { 232 | "name": "stdout", 233 | "output_type": "stream", 234 | "text": [ 235 | " event day\n", 236 | "0 Rain 1/1/2017\n", 237 | "1 Sunny 1/2/2017\n", 238 | "2 Snow 1/3/2017\n", 239 | "3 Snow 1/4/2017\n", 240 | "4 Rain 1/5/2017\n", 241 | "5 Sunny 1/6/2017\n" 242 | ] 243 | } 244 | ], 245 | "source": [ 246 | "print(df[['event', 'day']])" 247 | ] 248 | }, 249 | { 250 | "cell_type": "code", 251 | "execution_count": 11, 252 | "metadata": {}, 253 | "outputs": [ 254 | { 255 | "name": "stdout", 256 | "output_type": "stream", 257 | "text": [ 258 | "35\n" 259 | ] 260 | } 261 | ], 262 | "source": [ 263 | "print(df['temperature'].max())" 264 | ] 265 | }, 266 | { 267 | "cell_type": "code", 268 | "execution_count": 12, 269 | "metadata": {}, 270 | "outputs": [ 271 | { 272 | "name": "stdout", 273 | "output_type": "stream", 274 | "text": [ 275 | "describe(): \n", 276 | " temperature windspeed\n", 277 | "count 6.000000 6.000000\n", 278 | "mean 30.333333 4.666667\n", 279 | "std 3.829708 2.338090\n", 280 | "min 24.000000 2.000000\n", 281 | "25% 28.750000 2.500000\n", 282 | "50% 31.500000 5.000000\n", 283 | "75% 32.000000 6.750000\n", 284 | "max 35.000000 7.000000\n", 285 | "\n", 286 | "info()\n", 287 | "\n", 288 | "RangeIndex: 6 entries, 0 to 5\n", 289 | "Data columns (total 4 columns):\n", 290 | " # Column Non-Null Count Dtype \n", 291 | "--- ------ -------------- ----- \n", 292 | " 0 day 6 non-null object\n", 293 | " 1 temperature 6 non-null int64 \n", 294 | " 2 windspeed 6 non-null int64 \n", 295 | " 3 event 6 non-null object\n", 296 | "dtypes: int64(2), object(2)\n", 297 | "memory usage: 324.0+ bytes\n", 298 | "None\n" 299 | ] 300 | } 301 | ], 302 | "source": [ 303 | "print(\"describe(): \")\n", 304 | "print(df.describe())\n", 305 | "print()\n", 306 | "print(\"info()\")\n", 307 | "print(df.info())" 308 | ] 309 | }, 310 | { 311 | "cell_type": "code", 312 | "execution_count": 13, 313 | "metadata": {}, 314 | "outputs": [ 315 | { 316 | "name": "stdout", 317 | "output_type": "stream", 318 | "text": [ 319 | " day temperature windspeed event\n", 320 | "0 1/1/2017 32 6 Rain\n", 321 | "1 1/2/2017 35 7 Sunny\n", 322 | "4 1/5/2017 32 4 Rain\n", 323 | "5 1/6/2017 31 2 Sunny\n" 324 | ] 325 | } 326 | ], 327 | "source": [ 328 | "#conditional selection of data\n", 329 | "\n", 330 | "print(df[df['temperature'] >=31])" 331 | ] 332 | }, 333 | { 334 | "cell_type": "code", 335 | "execution_count": 14, 336 | "metadata": {}, 337 | "outputs": [ 338 | { 339 | "name": "stdout", 340 | "output_type": "stream", 341 | "text": [ 342 | " day event temperature\n", 343 | "1 1/2/2017 Sunny 35\n" 344 | ] 345 | } 346 | ], 347 | "source": [ 348 | "# print the day, event and temperature where temparature is maximum\n", 349 | "\n", 350 | "print(df[['day','event','temperature']][df['temperature']== df['temperature'].max()])" 351 | ] 352 | }, 353 | { 354 | "cell_type": "code", 355 | "execution_count": 15, 356 | "metadata": {}, 357 | "outputs": [ 358 | { 359 | "name": "stdout", 360 | "output_type": "stream", 361 | "text": [ 362 | "sum= 182\n", 363 | "mean= 30.333333333333332\n", 364 | "max= 35\n", 365 | "max= 35\n", 366 | "min= 24\n", 367 | "min= 24\n", 368 | "count= 6\n", 369 | "Standard Deviation= 3.8297084310253524\n" 370 | ] 371 | } 372 | ], 373 | "source": [ 374 | "# Aggregate functions\n", 375 | "print(\"sum= \",df['temperature'].sum())\n", 376 | "print(\"mean= \",df['temperature'].mean())\n", 377 | "print(\"max= \",df['temperature'].max())\n", 378 | "print(\"max= \",df['temperature'].max())\n", 379 | "print(\"min= \",df['temperature'].min())\n", 380 | "print(\"min= \",df['temperature'].min())\n", 381 | "print(\"count= \",df['temperature'].count())\n", 382 | "print(\"Standard Deviation= \",df['temperature'].std())" 383 | ] 384 | }, 385 | { 386 | "cell_type": "code", 387 | "execution_count": 16, 388 | "metadata": {}, 389 | "outputs": [ 390 | { 391 | "name": "stdout", 392 | "output_type": "stream", 393 | "text": [ 394 | " day temperature windspeed event\n", 395 | "0 1/1/2017 32 6 Rain\n", 396 | "1 1/2/2017 35 7 Sunny\n", 397 | "2 1/3/2017 28 2 Snow\n", 398 | "3 1/4/2017 24 7 Snow\n", 399 | "4 1/5/2017 32 4 Rain\n", 400 | "5 1/6/2017 31 2 Sunny\n" 401 | ] 402 | } 403 | ], 404 | "source": [ 405 | "df2 = df.copy()\n", 406 | "print(df2)" 407 | ] 408 | }, 409 | { 410 | "cell_type": "code", 411 | "execution_count": 17, 412 | "metadata": {}, 413 | "outputs": [ 414 | { 415 | "name": "stdout", 416 | "output_type": "stream", 417 | "text": [ 418 | "\n", 419 | "[1, 2, 3]\n", 420 | "Length: 3, dtype: int64\n" 421 | ] 422 | } 423 | ], 424 | "source": [ 425 | "df2 = pd.Series([1,2,3]).array\n", 426 | "print(df2)" 427 | ] 428 | }, 429 | { 430 | "cell_type": "markdown", 431 | "metadata": {}, 432 | "source": [ 433 | "## Pandas Documentation\n", 434 | "Click here " 435 | ] 436 | }, 437 | { 438 | "cell_type": "code", 439 | "execution_count": 18, 440 | "metadata": {}, 441 | "outputs": [ 442 | { 443 | "name": "stdout", 444 | "output_type": "stream", 445 | "text": [ 446 | " temperature windspeed event\n", 447 | "day \n", 448 | "1/1/2017 32 6 Rain\n", 449 | "1/2/2017 35 7 Sunny\n", 450 | "1/3/2017 28 2 Snow\n", 451 | "1/4/2017 24 7 Snow\n", 452 | "1/5/2017 32 4 Rain\n", 453 | "1/6/2017 31 2 Sunny\n" 454 | ] 455 | } 456 | ], 457 | "source": [ 458 | "#set index\n", 459 | "\n", 460 | "# df.set_index('day') \n", 461 | "# this will return a new object without changing the current object\n", 462 | "# to change the current object use inplace=True\n", 463 | "df.set_index('day', inplace=True)\n", 464 | "print(df)" 465 | ] 466 | }, 467 | { 468 | "cell_type": "code", 469 | "execution_count": 19, 470 | "metadata": {}, 471 | "outputs": [ 472 | { 473 | "data": { 474 | "text/plain": [ 475 | "temperature 28\n", 476 | "windspeed 2\n", 477 | "event Snow\n", 478 | "Name: 1/3/2017, dtype: object" 479 | ] 480 | }, 481 | "execution_count": 19, 482 | "metadata": {}, 483 | "output_type": "execute_result" 484 | } 485 | ], 486 | "source": [ 487 | "df.loc['1/3/2017']" 488 | ] 489 | }, 490 | { 491 | "cell_type": "code", 492 | "execution_count": 20, 493 | "metadata": {}, 494 | "outputs": [ 495 | { 496 | "name": "stdout", 497 | "output_type": "stream", 498 | "text": [ 499 | " day temperature windspeed event\n", 500 | "0 1/1/2017 32 6 Rain\n", 501 | "1 1/2/2017 35 7 Sunny\n", 502 | "2 1/3/2017 28 2 Snow\n", 503 | "3 1/4/2017 24 7 Snow\n", 504 | "4 1/5/2017 32 4 Rain\n", 505 | "5 1/6/2017 31 2 Sunny\n" 506 | ] 507 | } 508 | ], 509 | "source": [ 510 | "df.reset_index('day', inplace=True)\n", 511 | "print(df)" 512 | ] 513 | }, 514 | { 515 | "cell_type": "code", 516 | "execution_count": 21, 517 | "metadata": {}, 518 | "outputs": [], 519 | "source": [ 520 | "df.set_index('windspeed', inplace=True)" 521 | ] 522 | }, 523 | { 524 | "cell_type": "code", 525 | "execution_count": 22, 526 | "metadata": {}, 527 | "outputs": [ 528 | { 529 | "name": "stdout", 530 | "output_type": "stream", 531 | "text": [ 532 | " day temperature event\n", 533 | "windspeed \n", 534 | "6 1/1/2017 32 Rain\n", 535 | "7 1/2/2017 35 Sunny\n", 536 | "2 1/3/2017 28 Snow\n", 537 | "7 1/4/2017 24 Snow\n", 538 | "4 1/5/2017 32 Rain\n", 539 | "2 1/6/2017 31 Sunny\n" 540 | ] 541 | } 542 | ], 543 | "source": [ 544 | "print(df)" 545 | ] 546 | }, 547 | { 548 | "cell_type": "code", 549 | "execution_count": 29, 550 | "metadata": {}, 551 | "outputs": [ 552 | { 553 | "name": "stdout", 554 | "output_type": "stream", 555 | "text": [ 556 | "day 1/1/2017\n", 557 | "temperature 32\n", 558 | "event Rain\n", 559 | "Name: 6, dtype: object\n", 560 | "day 1/4/2017\n", 561 | "temperature 24\n", 562 | "event Snow\n", 563 | "Name: 7, dtype: object\n", 564 | "day 1/6/2017\n", 565 | "temperature 31\n", 566 | "event Sunny\n", 567 | "Name: 2, dtype: object\n" 568 | ] 569 | } 570 | ], 571 | "source": [ 572 | "print(df.iloc[0]) # 1st row data\n", 573 | "print(df.iloc[3]) # 4th row data\n", 574 | "print(df.iloc[5]) # 6th row data\n" 575 | ] 576 | } 577 | ], 578 | "metadata": { 579 | "kernelspec": { 580 | "display_name": "base", 581 | "language": "python", 582 | "name": "python3" 583 | }, 584 | "language_info": { 585 | "codemirror_mode": { 586 | "name": "ipython", 587 | "version": 3 588 | }, 589 | "file_extension": ".py", 590 | "mimetype": "text/x-python", 591 | "name": "python", 592 | "nbconvert_exporter": "python", 593 | "pygments_lexer": "ipython3", 594 | "version": "3.12.4" 595 | } 596 | }, 597 | "nbformat": 4, 598 | "nbformat_minor": 2 599 | } 600 | -------------------------------------------------------------------------------- /data_manipulation/dataframe_basics/weather_data.csv: -------------------------------------------------------------------------------- 1 | day,temperature,windspeed,event 2 | 1/1/2017,32,6,Rain 3 | 1/2/2017,35,7,Sunny 4 | 1/3/2017,28,2,Snow 5 | 1/4/2017,24,7,Snow 6 | 1/5/2017,32,4,Rain 7 | 1/6/2017,31,2,Sunny 8 | -------------------------------------------------------------------------------- /data_manipulation/messi.py: -------------------------------------------------------------------------------- 1 | 2 | import pandas as pd 3 | 4 | 5 | data = { 6 | 'Season': ['2017-2018', '2018-2019', '2019-2020', '2020-2021', '2021-2022'], 7 | 'Goals': [45, 51, 31, 38, 24], # Number of goals scored in each season 8 | 'Assists': [12, 19, 21, 9, 13] # Number of assists in each season 9 | } 10 | 11 | 12 | df = pd.DataFrame(data) 13 | 14 | print("Messi's Goal and Assist Stats by Season:") 15 | print(df) 16 | 17 | 18 | avg_goals = df['Goals'].mean() 19 | avg_assists = df['Assists'].mean() 20 | print("\nAverage Goals per Season:", avg_goals) 21 | print("Average Assists per Season:", avg_assists) 22 | 23 | max_goals_season = df.loc[df['Goals'].idxmax()] 24 | print("\nSeason with the Most Goals:") 25 | print(max_goals_season) 26 | 27 | 28 | total_goals = df['Goals'].sum() 29 | total_assists = df['Assists'].sum() 30 | print("\nTotal Goals:", total_goals) 31 | print("Total Assists:", total_assists) 32 | 33 | 34 | df['Goal-to-Assist Ratio'] = df['Goals'] / df['Assists'] 35 | print("\nGoal-to-Assist Ratio per Season:") 36 | print(df[['Season', 'Goal-to-Assist Ratio']]) 37 | -------------------------------------------------------------------------------- /data_visualization/Basic_Line_plot.py: -------------------------------------------------------------------------------- 1 | import pandas as pd 2 | import matplotlib.pyplot as plt 3 | 4 | data = { 5 | 'Year': [2019, 2020, 2021, 2022, 2023, 2024], 6 | 'Sales': [200, 250, 300, 350, 400, 450], 7 | 'Profit': [10, 40, 100, 80, 200, 150] 8 | } 9 | 10 | df = pd.DataFrame(data) 11 | ax = df.plot(x='Year', y='Sales', kind='line', marker='o', title='Sales and Profit Over Years') 12 | df.plot(x='Year', y='Profit', kind='line', marker='s', ax=ax, secondary_y=True) 13 | ax.set_ylabel('Sales') 14 | ax.right_ax.set_ylabel('Profit') 15 | ax.grid(True) 16 | plt.show() -------------------------------------------------------------------------------- /data_visualization/Box_plots.py: -------------------------------------------------------------------------------- 1 | import matplotlib.pyplot as plt 2 | import pandas as pd 3 | data = { 4 | 'Category': ['A']*10 + ['B']*10, 5 | 'Value': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] 6 | } 7 | df = pd.DataFrame(data) 8 | df.boxplot(by='Category') 9 | plt.title('Box Plot Example') 10 | plt.suptitle('') 11 | plt.xlabel('Category') 12 | plt.ylabel('Value') 13 | plt.show() -------------------------------------------------------------------------------- /data_visualization/Grouped_Bar_plots.py: -------------------------------------------------------------------------------- 1 | import pandas as pd 2 | import matplotlib.pyplot as plt 3 | 4 | data = { 5 | 'Nation': ['India', 'India', 'Pakistan', 'Pakistan', 'Bangladesh', 'Bangladesh', 'Nepal', 'Nepal'], 6 | 'Category': ['A', 'B', 'A', 'B', 'A', 'B', 'A', 'B'], 7 | 'Sales': [10, 15, 20, 25, 30, 35, 40, 45] 8 | } 9 | 10 | df = pd.DataFrame(data) 11 | pivot_df = df.pivot(index='Nation', columns='Category', values='Sales') 12 | pivot_df.plot(kind='bar', stacked=False) 13 | plt.title('Sales by Nation and Category') 14 | plt.xlabel('Nation') 15 | plt.ylabel('Sales') 16 | plt.show() -------------------------------------------------------------------------------- /data_visualization/Heatmap.py: -------------------------------------------------------------------------------- 1 | import matplotlib.pyplot as plt 2 | import numpy as np 3 | np.random.seed(0) 4 | data = np.random.rand(10, 10) 5 | plt.imshow(data, cmap='viridis', interpolation='nearest') 6 | plt.colorbar() 7 | plt.xlabel('X-axis Label') 8 | plt.ylabel('Y-axis Label') 9 | plt.title('Heatmap') 10 | plt.show() -------------------------------------------------------------------------------- /data_visualization/Housing_Price_Prediction.py: -------------------------------------------------------------------------------- 1 | 2 | import pandas as pd 3 | from sklearn.model_selection import train_test_split 4 | from sklearn.linear_model import LinearRegression 5 | from sklearn.metrics import mean_squared_error 6 | 7 | 8 | df = pd.read_csv('housing.csv') 9 | 10 | 11 | df.fillna(df.mean(), inplace=True) 12 | 13 | 14 | X = df[['feature1', 'feature2']] 15 | y = df['median_house_value'] 16 | 17 | 18 | X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42) 19 | 20 | 21 | model = LinearRegression() 22 | model.fit(X_train, y_train) 23 | 24 | 25 | y_pred = model.predict(X_test) 26 | 27 | 28 | mse = mean_squared_error(y_test, y_pred) 29 | print("Mean Squared Error:", mse) 30 | 31 | 32 | print(pd.DataFrame({'Actual': y_test, 'Predicted': y_pred}).head()) 33 | -------------------------------------------------------------------------------- /data_visualization/line chart.py: -------------------------------------------------------------------------------- 1 | import matplotlib.pyplot as plt 2 | 3 | # initializing the data 4 | x = [5, 10, 15, 20, 25, 30, 35, 40, 45, 50] 5 | y1 = [2345, 3000, 4975, 5067, 6700, 7890, 8000, 9012, 10023, 12069] 6 | 7 | # plotting the data for x and y1 and adding a label Y1 8 | plt.plot(x, y1, label='Y1') 9 | 10 | y2 = [3986, 4253, 4986, 5825, 7244, 8321, 9575, 10056, 10489, 11099] 11 | 12 | # plotting data for x, y1 and y2 and adding a label Y2 13 | plt.plot(x,y2, label='Y2') 14 | 15 | # adding title to the plot 16 | plt.title("Line Chart") 17 | 18 | # adding label on the y-axis 19 | plt.ylabel('Y-Axis') 20 | 21 | # adding label on the x-axis 22 | plt.xlabel('X-Axis') 23 | 24 | # adding a guide or key or legend to the graph 25 | plt.legend() 26 | 27 | # adding grid 28 | plt.grid() 29 | 30 | plt.show() 31 | -------------------------------------------------------------------------------- /data_visualization/pie_chart.py: -------------------------------------------------------------------------------- 1 | import matplotlib.pyplot as plt 2 | import numpy as np 3 | 4 | y = np.array([45, 25, 15, 10]) 5 | mylabels = ["Procrastination", "StackOverflow", "Debugging", "Coding"] 6 | mycolors = ["#4B0082", "#9B3192", "#EA5789", "#F7B7A3"] 7 | 8 | # Explode one or more slices (e.g., the first slice) 9 | myexplode = (0.1, 0, 0, 0) 10 | plt.pie(y, labels=mylabels, colors=mycolors, explode=myexplode, autopct='%1.1f%%') 11 | 12 | plt.legend(title="Life of a programmer:", loc="center right") 13 | plt.axis('equal') 14 | 15 | plt.show() -------------------------------------------------------------------------------- /deep_learning/mnist_cnn_classifier.py: -------------------------------------------------------------------------------- 1 | # Import necessary libraries 2 | import tensorflow as tf 3 | from tensorflow.keras import layers, models 4 | from tensorflow.keras.datasets import mnist 5 | from tensorflow.keras.utils import to_categorical 6 | 7 | # Load and preprocess the MNIST dataset 8 | (X_train, y_train), (X_test, y_test) = mnist.load_data() 9 | 10 | # Normalize the pixel values 11 | X_train, X_test = X_train / 255.0, X_test / 255.0 12 | 13 | # Reshape the data to fit the model input shape (28x28x1) 14 | X_train = X_train.reshape(-1, 28, 28, 1) 15 | X_test = X_test.reshape(-1, 28, 28, 1) 16 | 17 | # One-hot encode the labels 18 | y_train = to_categorical(y_train, 10) 19 | y_test = to_categorical(y_test, 10) 20 | 21 | # Build a simple neural network model 22 | model = models.Sequential([ 23 | layers.Conv2D(32, kernel_size=(3, 3), activation='relu', input_shape=(28, 28, 1)), 24 | layers.MaxPooling2D(pool_size=(2, 2)), 25 | layers.Flatten(), 26 | layers.Dense(128, activation='relu'), 27 | layers.Dense(10, activation='softmax') # Output layer with 10 classes (digits 0-9) 28 | ]) 29 | 30 | # Compile the model 31 | model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy']) 32 | 33 | # Train the model 34 | model.fit(X_train, y_train, epochs=5, batch_size=32, validation_split=0.1) 35 | 36 | # Evaluate the model on test data 37 | test_loss, test_accuracy = model.evaluate(X_test, y_test, verbose=0) 38 | 39 | # Print the test accuracy 40 | print(f"Test Accuracy: {test_accuracy * 100:.2f}%") 41 | -------------------------------------------------------------------------------- /machine_learning/PCA_2D_to_1D.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "nbformat": 4, 3 | "nbformat_minor": 0, 4 | "metadata": { 5 | "colab": { 6 | "provenance": [] 7 | }, 8 | "kernelspec": { 9 | "name": "python3", 10 | "display_name": "Python 3" 11 | }, 12 | "language_info": { 13 | "name": "python" 14 | } 15 | }, 16 | "cells": [ 17 | { 18 | "cell_type": "markdown", 19 | "source": [ 20 | "# **Converting a 2D dataset to 1D Data using PCA (Principal Component Analysis**\n", 21 | "### Project By: Aditya Ghosh\n", 22 | "[Linkedin](https://www.linkedin.com/in/adityaghosh2992/) [Github](https://github.com/aditya-ghosh2992)\n", 23 | "\n" 24 | ], 25 | "metadata": { 26 | "id": "Xinx-ztxTcoT" 27 | } 28 | }, 29 | { 30 | "cell_type": "code", 31 | "execution_count": 1, 32 | "metadata": { 33 | "id": "oSyhjG2Xpf0x" 34 | }, 35 | "outputs": [], 36 | "source": [ 37 | "import numpy as np\n", 38 | "import matplotlib.pyplot as plt\n" 39 | ] 40 | }, 41 | { 42 | "cell_type": "code", 43 | "source": [ 44 | "#step 1: Generate 1 2D data\n", 45 | "np.random.seed(0)\n", 46 | "mean = [0,0]\n", 47 | "cov = [[1, 0.8], [0.8, 1]]\n", 48 | "data = np.random.multivariate_normal(mean, cov, 100)\n", 49 | "plt.scatter(data[:,0], data[:,1])\n", 50 | "plt.show" 51 | ], 52 | "metadata": { 53 | "colab": { 54 | "base_uri": "https://localhost:8080/", 55 | "height": 599 56 | }, 57 | "id": "WnFVT5wwqDbY", 58 | "outputId": "ba76df6f-ae32-4ec6-d7bc-15ded126203d" 59 | }, 60 | "execution_count": 2, 61 | "outputs": [ 62 | { 63 | "output_type": "execute_result", 64 | "data": { 65 | "text/plain": [ 66 | "" 67 | ], 68 | "text/html": [ 69 | "
\n", 81 | " 
matplotlib.pyplot.show
def show(*args, **kwargs)
/usr/local/lib/python3.10/dist-packages/matplotlib/pyplot.pyDisplay all open figures.\n",
 84 |               "\n",
 85 |               "Parameters\n",
 86 |               "----------\n",
 87 |               "block : bool, optional\n",
 88 |               "    Whether to wait for all figures to be closed before returning.\n",
 89 |               "\n",
 90 |               "    If `True` block and run the GUI main loop until all figure windows\n",
 91 |               "    are closed.\n",
 92 |               "\n",
 93 |               "    If `False` ensure that all figure windows are displayed and return\n",
 94 |               "    immediately.  In this case, you are responsible for ensuring\n",
 95 |               "    that the event loop is running to have responsive figures.\n",
 96 |               "\n",
 97 |               "    Defaults to True in non-interactive mode and to False in interactive\n",
 98 |               "    mode (see `.pyplot.isinteractive`).\n",
 99 |               "\n",
100 |               "See Also\n",
101 |               "--------\n",
102 |               "ion : Enable interactive mode, which shows / updates the figure after\n",
103 |               "      every plotting command, so that calling ``show()`` is not necessary.\n",
104 |               "ioff : Disable interactive mode.\n",
105 |               "savefig : Save the figure to an image file instead of showing it on screen.\n",
106 |               "\n",
107 |               "Notes\n",
108 |               "-----\n",
109 |               "**Saving figures to file and showing a window at the same time**\n",
110 |               "\n",
111 |               "If you want an image file as well as a user interface window, use\n",
112 |               "`.pyplot.savefig` before `.pyplot.show`. At the end of (a blocking)\n",
113 |               "``show()`` the figure is closed and thus unregistered from pyplot. Calling\n",
114 |               "`.pyplot.savefig` afterwards would save a new and thus empty figure. This\n",
115 |               "limitation of command order does not apply if the show is non-blocking or\n",
116 |               "if you keep a reference to the figure and use `.Figure.savefig`.\n",
117 |               "\n",
118 |               "**Auto-show in jupyter notebooks**\n",
119 |               "\n",
120 |               "The jupyter backends (activated via ``%matplotlib inline``,\n",
121 |               "``%matplotlib notebook``, or ``%matplotlib widget``), call ``show()`` at\n",
122 |               "the end of every cell by default. Thus, you usually don't have to call it\n",
123 |               "explicitly there.
\n", 124 | " \n", 143 | "
" 144 | ] 145 | }, 146 | "metadata": {}, 147 | "execution_count": 2 148 | }, 149 | { 150 | "output_type": "display_data", 151 | "data": { 152 | "text/plain": [ 153 | "
" 154 | ], 155 | "image/png": "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\n" 156 | }, 157 | "metadata": {} 158 | } 159 | ] 160 | }, 161 | { 162 | "cell_type": "code", 163 | "source": [ 164 | "# Step 2: standardize the dataset\n", 165 | "data_mean = np.mean(data,axis=0)\n", 166 | "data_centered = data - data_mean" 167 | ], 168 | "metadata": { 169 | "id": "_jv02U9mryPr" 170 | }, 171 | "execution_count": 3, 172 | "outputs": [] 173 | }, 174 | { 175 | "cell_type": "code", 176 | "source": [ 177 | "# step 3: compute the covariance matrix\n", 178 | "con_matrix = np.cov(data_centered.T)\n", 179 | "print(con_matrix)" 180 | ], 181 | "metadata": { 182 | "colab": { 183 | "base_uri": "https://localhost:8080/" 184 | }, 185 | "id": "lI09UEwTsYxW", 186 | "outputId": "fb2f04d0-54af-4646-8cc4-8cb53cea172e" 187 | }, 188 | "execution_count": 4, 189 | "outputs": [ 190 | { 191 | "output_type": "stream", 192 | "name": "stdout", 193 | "text": [ 194 | "[[1.03857986 0.84522228]\n", 195 | " [0.84522228 1.06878628]]\n" 196 | ] 197 | } 198 | ] 199 | }, 200 | { 201 | "cell_type": "code", 202 | "source": [ 203 | "#step4 : calculate eignvalue and eignvectors\n", 204 | "eignvalues, eignvectors = np.linalg.eig(con_matrix)\n", 205 | "print(eignvalues)\n", 206 | "print(eignvectors)" 207 | ], 208 | "metadata": { 209 | "colab": { 210 | "base_uri": "https://localhost:8080/" 211 | }, 212 | "id": "dhUqqV-gs6pB", 213 | "outputId": "d5e523a2-9903-446d-fb8f-a345725b480e" 214 | }, 215 | "execution_count": 5, 216 | "outputs": [ 217 | { 218 | "output_type": "stream", 219 | "name": "stdout", 220 | "text": [ 221 | "[0.20832587 1.89904028]\n", 222 | "[[-0.71339543 -0.7007617 ]\n", 223 | " [ 0.7007617 -0.71339543]]\n" 224 | ] 225 | } 226 | ] 227 | }, 228 | { 229 | "cell_type": "code", 230 | "source": [ 231 | "# step 5 : sort eignvalues and eignvector\n", 232 | "sorted_indices = np.argsort(eignvalues)[::-1] # sort in desecending oreder\n", 233 | "sorted_eignvalues = eignvalues[sorted_indices]\n", 234 | "sorted_eignvectors = eignvectors[:,sorted_indices]\n", 235 | "print(sorted_eignvalues)\n", 236 | "print(sorted_eignvectors)" 237 | ], 238 | "metadata": { 239 | "colab": { 240 | "base_uri": "https://localhost:8080/" 241 | }, 242 | "id": "MTR1mYfmtza4", 243 | "outputId": "b3418b30-eabf-4660-ebfc-111f587c77f0" 244 | }, 245 | "execution_count": 6, 246 | "outputs": [ 247 | { 248 | "output_type": "stream", 249 | "name": "stdout", 250 | "text": [ 251 | "[1.89904028 0.20832587]\n", 252 | "[[-0.7007617 -0.71339543]\n", 253 | " [-0.71339543 0.7007617 ]]\n" 254 | ] 255 | } 256 | ] 257 | }, 258 | { 259 | "cell_type": "code", 260 | "source": [ 261 | "#step 6: choose the top K eignvector(1D)\n", 262 | "K=1\n", 263 | "top_k_eignvectors = sorted_eignvectors[:,:K]\n", 264 | "print(top_k_eignvectors)" 265 | ], 266 | "metadata": { 267 | "colab": { 268 | "base_uri": "https://localhost:8080/" 269 | }, 270 | "id": "2tAKK-TYvE7i", 271 | "outputId": "319b50f6-6dc5-4446-d2bd-61b7667a15ae" 272 | }, 273 | "execution_count": 7, 274 | "outputs": [ 275 | { 276 | "output_type": "stream", 277 | "name": "stdout", 278 | "text": [ 279 | "[[-0.7007617 ]\n", 280 | " [-0.71339543]]\n" 281 | ] 282 | } 283 | ] 284 | }, 285 | { 286 | "cell_type": "code", 287 | "source": [ 288 | "# step 7: project the data onto PC\n", 289 | "data_1d = np.dot(data_centered, top_k_eignvectors)\n", 290 | "print(data_1d)" 291 | ], 292 | "metadata": { 293 | "colab": { 294 | "base_uri": "https://localhost:8080/" 295 | }, 296 | "id": "5nM8qLhhv-FZ", 297 | "outputId": "7908d331-ee9a-412f-b54b-af2ce94e4531" 298 | }, 299 | "execution_count": 8, 300 | "outputs": [ 301 | { 302 | "output_type": "stream", 303 | "name": "stdout", 304 | "text": [ 305 | "[[ 2.36688669]\n", 306 | " [ 1.30596497]\n", 307 | " [ 2.51125158]\n", 308 | " [ 1.27708643]\n", 309 | " [-0.13826226]\n", 310 | " [ 0.18929224]\n", 311 | " [ 1.02236763]\n", 312 | " [ 0.59600341]\n", 313 | " [ 2.0071123 ]\n", 314 | " [ 0.4252751 ]\n", 315 | " [-3.42581465]\n", 316 | " [ 1.16453686]\n", 317 | " [ 3.05273948]\n", 318 | " [ 0.0639921 ]\n", 319 | " [ 2.052342 ]\n", 320 | " [ 0.20821991]\n", 321 | " [-1.18127326]\n", 322 | " [-0.46552391]\n", 323 | " [ 1.64759386]\n", 324 | " [-0.51656975]\n", 325 | " [-1.39919689]\n", 326 | " [-2.29504871]\n", 327 | " [-0.68013747]\n", 328 | " [-1.68198523]\n", 329 | " [-2.16247962]\n", 330 | " [-1.20103702]\n", 331 | " [-0.67871764]\n", 332 | " [-0.03766493]\n", 333 | " [ 0.08988548]\n", 334 | " [-0.847694 ]\n", 335 | " [-0.89887267]\n", 336 | " [-1.08215472]\n", 337 | " [ 0.24149305]\n", 338 | " [-2.18704696]\n", 339 | " [-1.21557221]\n", 340 | " [ 0.97947853]\n", 341 | " [ 1.53539396]\n", 342 | " [ 0.54436756]\n", 343 | " [-1.16408254]\n", 344 | " [-0.41634406]\n", 345 | " [-1.56489386]\n", 346 | " [ 0.63271952]\n", 347 | " [ 1.99090107]\n", 348 | " [ 1.5840097 ]\n", 349 | " [-1.43886551]\n", 350 | " [-0.54392565]\n", 351 | " [ 0.27737249]\n", 352 | " [ 0.47712899]\n", 353 | " [ 0.00880714]\n", 354 | " [ 0.17051288]\n", 355 | " [ 2.53365068]\n", 356 | " [-1.70648411]\n", 357 | " [-1.5797572 ]\n", 358 | " [-0.55006454]\n", 359 | " [ 2.57573489]\n", 360 | " [ 2.50372875]\n", 361 | " [-1.16118513]\n", 362 | " [-0.36090059]\n", 363 | " [ 1.27329568]\n", 364 | " [ 0.82201195]\n", 365 | " [ 0.51125518]\n", 366 | " [ 0.39666868]\n", 367 | " [-0.92937034]\n", 368 | " [-0.58932928]\n", 369 | " [ 0.90216944]\n", 370 | " [-1.03320873]\n", 371 | " [-0.90294803]\n", 372 | " [-0.8538902 ]\n", 373 | " [ 0.7762343 ]\n", 374 | " [ 0.53749972]\n", 375 | " [-2.00055237]\n", 376 | " [ 0.22292523]\n", 377 | " [ 3.19527856]\n", 378 | " [-1.22723805]\n", 379 | " [-1.76170528]\n", 380 | " [-0.09654187]\n", 381 | " [-0.99399661]\n", 382 | " [-0.12757673]\n", 383 | " [ 1.51765009]\n", 384 | " [-1.53582493]\n", 385 | " [-0.67400749]\n", 386 | " [ 1.2752363 ]\n", 387 | " [-1.64554678]\n", 388 | " [-1.33384936]\n", 389 | " [ 1.59443463]\n", 390 | " [ 1.23599433]\n", 391 | " [ 1.15396919]\n", 392 | " [-1.38839484]\n", 393 | " [-1.07323409]\n", 394 | " [-0.6093512 ]\n", 395 | " [-0.46756537]\n", 396 | " [-0.85273222]\n", 397 | " [ 0.84705821]\n", 398 | " [-1.47997978]\n", 399 | " [-0.9964976 ]\n", 400 | " [-1.73369202]\n", 401 | " [-0.04617941]\n", 402 | " [ 0.70456188]\n", 403 | " [ 1.03398959]\n", 404 | " [ 2.8986854 ]]\n" 405 | ] 406 | } 407 | ] 408 | }, 409 | { 410 | "cell_type": "code", 411 | "source": [ 412 | "# step 8 : Plot the original data and projection\n", 413 | "plt.figure(figsize=(12,6))\n", 414 | "plt.subplot(1,2,1)\n", 415 | "plt.scatter(data[:,0], data[:,1],alpha=0.5)\n", 416 | "plt.title('Original Data')\n", 417 | "plt.xlabel('X-axis')\n", 418 | "plt.ylabel('Y-axis')\n", 419 | "plt.axis('equal')\n", 420 | "\n", 421 | "plt.subplot(1,2,2)\n", 422 | "plt.scatter(data_1d[:,0], np.zeros_like(data_1d[:,0]), alpha=0.5,color='orange')\n", 423 | "plt.title('Projected Data')\n", 424 | "plt.xlabel('PC1')\n", 425 | "plt.ylabel([])\n", 426 | "plt.axhline(0, color= 'gray', lw=0.5)\n", 427 | "\n", 428 | "plt.tight_layout()\n", 429 | "plt.show()\n" 430 | ], 431 | "metadata": { 432 | "colab": { 433 | "base_uri": "https://localhost:8080/", 434 | "height": 607 435 | }, 436 | "id": "fn31bu2bwXAv", 437 | "outputId": "94501ebf-0244-442a-a269-e1a9aaa8fd85" 438 | }, 439 | "execution_count": 9, 440 | "outputs": [ 441 | { 442 | "output_type": "display_data", 443 | "data": { 444 | "text/plain": [ 445 | "
" 446 | ], 447 | "image/png": "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\n" 448 | }, 449 | "metadata": {} 450 | } 451 | ] 452 | } 453 | ] 454 | } -------------------------------------------------------------------------------- /machine_learning/knn_classifier_iris.py: -------------------------------------------------------------------------------- 1 | # Import necessary libraries 2 | from sklearn.model_selection import train_test_split 3 | from sklearn.neighbors import KNeighborsClassifier 4 | from sklearn.datasets import load_iris 5 | from sklearn.metrics import accuracy_score 6 | 7 | # Load the Iris dataset 8 | iris = load_iris() 9 | X = iris.data # Features 10 | y = iris.target # Target labels 11 | 12 | # Split the dataset into training and testing sets (80% train, 20% test) 13 | X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42) 14 | 15 | # Initialize the KNN classifier with 3 neighbors 16 | knn = KNeighborsClassifier(n_neighbors=3) 17 | 18 | # Train the model using the training data 19 | knn.fit(X_train, y_train) 20 | 21 | # Make predictions on the test set 22 | y_pred = knn.predict(X_test) 23 | 24 | # Calculate the accuracy of the model 25 | accuracy = accuracy_score(y_test, y_pred) 26 | 27 | # Print the accuracy 28 | print(f"Model Accuracy: {accuracy * 100:.2f}%") 29 | -------------------------------------------------------------------------------- /machine_learning/lowest_ranked_movies/decision_tree_regressor.py: -------------------------------------------------------------------------------- 1 | import pandas as pd 2 | from sklearn.metrics import mean_absolute_error 3 | from sklearn.model_selection import train_test_split 4 | from sklearn.tree import DecisionTreeRegressor 5 | 6 | regressor = DecisionTreeRegressor(random_state = 3) 7 | movies = pd.read_csv('machine_learning/lowest_ranked_movies/movies.csv') 8 | temp = ["duration" , "review_count"] 9 | X = movies[temp] 10 | y = movies.rating 11 | 12 | X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.1, random_state = 10) 13 | regressor.fit(X_train, y_train) 14 | 15 | y_pred = regressor.predict(X_test) 16 | accuracy = mean_absolute_error(y_test, y_pred) 17 | print(f"accuracy of the model : {accuracy*100: .3f}") -------------------------------------------------------------------------------- /machine_learning/lowest_ranked_movies/movies.csv: -------------------------------------------------------------------------------- 1 | rank,name,year,certification,duration,rating,review_count,director,writer,genre,stars 2 | 1,Disaster Movie,2008,PG-13,1.27,1.9,94,"['Jason Friedberg', 'Aaron Seltzer']","['Jason Friedberg', 'Aaron Seltzer']","['Comedy', 'Sci-Fi']","['Carmen Electra', 'Vanessa Lachey', 'Nicole Parker']" 3 | 2,Manos: The Hands of Fate,1966,Not Rated,1.1,1.6,37,['Harold P. Warren'],['Harold P. Warren'],['Horror'],"['Tom Neyman', 'John Reynolds', 'Diane Adelson']" 4 | 3,Birdemic: Shock and Terror,2010,Not Rated,1.45,1.7,25,['James Nguyen'],"['Writer', 'James Nguyen', '']","['Horror', 'Thriller']","['Alan Bagh', 'Whitney Moore', 'Tippi Hedren']" 5 | 4,Superbabies: Baby Geniuses 2,2004,PG,1.28,1.5,32,['Bob Clark'],"['Writers', 'Robert Grasmere', 'Francisca Matos', 'Steven Paul', '']","['Comedy', 'Family', 'Sci-Fi']","['Jon Voight', 'Scott Baio', 'Vanessa Angel']" 6 | 5,The Hottie & the Nottie,2008,PG-13,1.31,2.0,39,['Tom Putnam'],['Heidi Ferrer'],"['Comedy', 'Romance']","['Paris Hilton', 'Joel David Moore', 'Christine Lakin']" 7 | 6,Kirk Cameron's Saving Christmas,2014,PG,1.19,1.3,17,['Darren Doane'],"['Darren Doane', 'Cheston Hervey']","['Comedy', 'Family']","['Kirk Cameron', 'Darren Doane', 'Bridgette Cameron']" 8 | 7,House of the Dead,2003,R,1.3,2.1,38,['Uwe Boll'],"['Writers', 'Mark A. Altman', 'Dan Bates', 'Dave Parker', '']","['Action', 'Adventure', 'Horror']","['Jonathan Cherry', 'Tyron Leitso', 'Clint Howard']" 9 | 8,Son of the Mask,2005,PG,1.34,2.3,59,['Lawrence Guterman'],['Lance Khazei'],"['Comedy', 'Family', 'Fantasy']","['Jamie Kennedy', 'Traylor Howard', 'Alan Cumming']" 10 | 9,Epic Movie,2007,PG-13,1.26,2.4,109,"['Jason Friedberg', 'Aaron Seltzer']","['Jason Friedberg', 'Aaron Seltzer']","['Adventure', 'Comedy', 'Fantasy']","['Kal Penn', 'Jennifer Coolidge', 'Fred Willard']" 11 | 10,Radhe,2021,TV-MA,1.49,1.9,179,['Prabhu Deva'],"['Writers', 'Vijay Maurya', 'A.C. Mughil', '']","['Action', 'Crime', 'Thriller']","['Salman Khan', 'Disha Patani', 'Randeep Hooda']" 12 | 11,Battlefield Earth,2000,PG-13,1.57,2.5,82,['Roger Christian'],"['Corey Mandell', 'J.D. Shapiro', 'L. Ron Hubbard']","['Action', 'Adventure', 'Sci-Fi']","['John Travolta', 'Forest Whitaker', 'Barry Pepper']" 13 | 12,Pledge This!,2006,R,1.31,1.7,19,"['William Heins', 'Strathford Hamilton']","['Cheryl Guerriero', 'Anna Obropta']",['Comedy'],"['Paris Hilton', 'Simon Rex', 'Paula Garcés']" 14 | 13,Alone in the Dark,2005,R,1.36,2.4,47,['Uwe Boll'],"['Elan Mastai', 'Michael Roesch', 'Peter Scheerer']","['Action', 'Horror', 'Sci-Fi']","['Christian Slater', 'Tara Reid', 'Stephen Dorff']" 15 | 14,Dragonball Evolution,2009,PG,1.25,2.5,78,['James Wong'],"['Ben Ramsey', 'Akira Toriyama']","['Action', 'Adventure', 'Fantasy']","['Justin Chatwin', 'James Marsters', 'Chow Yun-Fat']" 16 | 15,Race 3,2018,Not Rated,2.4,1.9,48,"[""Remo D'Souza""]","['Writers', 'Shiraz Ahmed', 'Kiran Kotrial', 'Athar Nawaaz', '']","['Action', 'Crime', 'Thriller']","['Anil Kapoor', 'Salman Khan', 'Bobby Deol']" 17 | 16,From Justin to Kelly,2003,PG,1.21,1.9,27,['Robert Iscove'],['Kim Fuller'],"['Comedy', 'Musical', 'Romance']","['Kelly Clarkson', 'Justin Guarini', 'Katherine Bailess']" 18 | 17,Foodfight!,2012,PG,1.31,1.3,12,['Lawrence Kasanoff'],"['Writers', 'Lawrence Kasanoff', 'Joshua Wexler', 'Brent V. Friedman', '']","['Animation', 'Action', 'Adventure']","['Hilary Duff', 'Haylie Duff', 'Charlie Sheen']" 19 | 18,Going Overboard,1989,R,1.39,1.8,14,['Valerie Breiman'],"['Writers', 'Valerie Breiman', 'Adam Sandler', 'Scott LaRose', '']",['Comedy'],"['Adam Sandler', 'Billy Bob Thornton', 'Billy Zane']" 20 | 19,Turks in Space,2006,Not Rated,1.5,1.5,17,['Kartal Tibet'],['Murat Boyacioglu'],"['Action', 'Comedy', 'Sci-Fi']","['Cüneyt Arkin', 'Miraç Bayramoglu', 'Haldun Boysan']" 21 | 20,Meet the Spartans,2008,PG-13,1.27,2.8,111,"['Jason Friedberg', 'Aaron Seltzer']","['Jason Friedberg', 'Aaron Seltzer']","['Comedy', 'Fantasy']","['Sean Maguire', 'Kevin Sorbo', 'Carmen Electra']" 22 | 21,Gigli,2003,R,0.21,2.6,50,['Martin Brest'],['Martin Brest'],"['Comedy', 'Crime', 'Romance']","['Ben Affleck', 'Jennifer Lopez', 'Justin Bartha']" 23 | 22,Date Movie,2006,PG-13,1.23,2.8,62,"['Aaron Seltzer', 'Jason Friedberg']","['Jason Friedberg', 'Aaron Seltzer']","['Comedy', 'Romance']","['Alyson Hannigan', 'Adam Campbell', 'Fred Willard']" 24 | 23,Cats,2019,PG,1.5,2.8,55,['Tom Hooper'],"['Writers', 'Lee Hall', 'Tom Hooper', 'Andrew Lloyd Webber', '']","['Comedy', 'Drama', 'Family']","['James Corden', 'Judi Dench', 'Jason Derulo']" 25 | 24,Daniel the Wizard,2004,Not Rated,1.21,1.2,15,['Ulli Lommel'],['Ulli Lommel'],"['Comedy', 'Crime', 'Fantasy']","['Daniel Küblböck', 'Ulli Lommel', 'Rudolf Waldemar Brem']" 26 | 25,Baby Geniuses,1999,PG,1.37,2.6,27,['Bob Clark'],"['Writers', 'Steven Paul', 'Francisca Matos', 'Robert Grasmere', '']","['Comedy', 'Crime', 'Family']","['Kathleen Turner', 'Christopher Lloyd', 'Kim Cattrall']" 27 | 26,Glitter,2001,PG-13,1.44,2.4,24,['Vondie Curtis-Hall'],"['Cheryl L. West', 'Kate Lanier']","['Drama', 'Music', 'Romance']","['Mariah Carey', 'Eric Benét', 'Max Beesley']" 28 | 27,The Human Centipede III (Final Sequence),2015,Not Rated,1.42,2.7,19,['Tom Six'],['Tom Six'],"['Comedy', 'Horror']","['Dieter Laser', 'Laurence R. Harvey', 'Eric Roberts']" 29 | 28,Cosmic Sin,2021,R,1.28,2.5,15,['Edward Drake'],"['Edward Drake', 'Corey Large']","['Action', 'Sci-Fi']","['Frank Grillo', 'Bruce Willis', 'Brandon Thomas Lee']" 30 | 29,Jaws: The Revenge,1987,PG-13,1.29,3.0,49,['Joseph Sargent'],"['Writers', 'Peter Benchley', 'Michael De Guzman', '']","['Adventure', 'Horror', 'Thriller']","['Lorraine Gary', 'Lance Guest', 'Mario Van Peebles']" 31 | 30,Troll 2,1990,PG-13,1.35,2.9,34,['Claudio Fragasso'],"['Writers', 'Rossella Drudi', 'Claudio Fragasso', '']","['Comedy', 'Fantasy', 'Horror']","['Michael Paul Stephenson', 'George Hardy', 'Margo Prey']" 32 | 31,BloodRayne,2005,R,1.35,3.0,37,['Uwe Boll'],['Guinevere Turner'],"['Action', 'Fantasy', 'Horror']","['Kristanna Loken', 'Ben Kingsley', 'Michelle Rodriguez']" 33 | 32,Mega Shark vs. Giant Octopus,2009,R,1.28,2.5,11,['Jack Perez'],['Jack Perez'],"['Action', 'Adventure', 'Comedy']","['Lorenzo Lamas', 'Debbie Gibson', 'Vic Chao']" 34 | 33,365 Days: This Day,2022,TV-MA,1.51,2.6,23,"['Barbara Bialowas', 'Tomasz Mandes']","['Writers', 'Mojca Tirs', 'Blanka Lipinska', 'Tomasz Mandes', '']","['Drama', 'Romance']","['Anna-Maria Sieklucka', 'Michele Morrone', 'Simone Susinna']" 35 | 34,Jeepers Creepers: Reborn,2022,R,1.28,2.5,13,['Timo Vuorensola'],"['Jake Seal', 'Sean-Michael Argo']","['Horror', 'Mystery', 'Thriller']","['Gary Graham', 'Dee Wallace', 'Timo Vuorensola']" 36 | 35,Hobgoblins,1988,Not Rated,1.28,2.2,12,['Rick Sloane'],['Rick Sloane'],"['Comedy', 'Horror', 'Sci-Fi']","['Tom Bartlett', 'Paige Sullivan', 'Steven Boggs']" 37 | 36,Left Behind,2014,PG-13,1.5,3.1,42,['Vic Armstrong'],"['Writers', 'Paul Lalonde', 'John Patus', 'Tim LaHaye', '']","['Action', 'Fantasy', 'Sci-Fi']","['Nicolas Cage', 'Lea Thompson', 'Cassi Thomson']" 38 | 37,The Cost of Deception,2021,,0.0,1.5,40,['Keith English'],"['Writer', 'Balázs Bendi', '']","['Action', 'Crime', 'Drama']","['Vivianne Bánovits', 'András Mózes', 'Barna Bokor']" 39 | 38,365 Days,2020,TV-MA,1.54,3.3,96,"['Barbara Bialowas', 'Tomasz Mandes']","['Writers', 'Tomasz Klimala', 'Tomasz Mandes', 'Barbara Bialowas', '']","['Drama', 'Romance']","['Anna-Maria Sieklucka', 'Michele Morrone', 'Bronislaw Wroclawski']" 40 | 39,Enes Batur: Imagination or Reality?,2018,,0.0,2.0,56,['Kamil Cetin'],"['Enes Batur', 'Busra Nur Karahan', 'Enver Sülük']",['Comedy'],"['Enes Batur', 'Bilal Hanci', 'Atakan Özyurt']" 41 | 40,Who's Your Caddy?,2007,PG-13,1.33,2.2,15,['Don Michael Paul'],"['Don Michael Paul', 'Bradley Allenstein', 'Robert Henny']","['Comedy', 'Sport']","['Big Boi', 'Jeffrey Jones', 'Terry Crews']" 42 | 41,Jack and Jill,2011,PG,1.31,3.3,89,['Dennis Dugan'],"['Writers', 'Ben Zook', 'Steve Koren', 'Adam Sandler', '']",['Comedy'],"['Adam Sandler', 'Katie Holmes', 'Al Pacino']" 43 | 42,Rollerball,2002,PG-13,1.38,3.1,29,['John McTiernan'],"['Writers', 'William Harrison', 'Larry Ferguson', 'John Pogue', '']","['Action', 'Sci-Fi', 'Sport']","['Chris Klein', 'Jean Reno', 'LL Cool J']" 44 | 43,Santa Claus Conquers the Martians,1964,Not Rated,1.21,2.7,12,['Nicholas Webster'],"['Glenville Mareth', 'Paul L. Jacobson']","['Adventure', 'Comedy', 'Family']","['John Call', 'Leonard Hicks', 'Vincent Beck']" 45 | 44,Adipurush,2023,,0.0,3.4,131,['Om Raut'],"['Writers', 'Manoj Muntashir', 'Om Raut', '']","['Action', 'Adventure', 'Drama']","['Kriti Sanon', 'Saif Ali Khan', 'Prabhas']" 46 | 45,Winnie the Pooh: Blood and Honey,2023,Not Rated,1.24,2.9,24,['Rhys Frake-Waterfield'],"['Rhys Frake-Waterfield', 'A.A. Milne']",['Horror'],"['Nikolai Leon', 'Maria Taylor', 'Natasha Rose Mills']" 47 | 46,Slender Man,2018,PG-13,1.33,3.2,37,['Sylvain White'],"['David Birke', 'Victor Surge']","['Horror', 'Mystery', 'Thriller']","['Joey King', 'Julia Goldani Telles', 'Jaz Sinclair']" 48 | 47,Catwoman,2004,PG-13,1.44,3.4,124,['Pitof'],"['Writers', 'Bob Kane', 'Theresa Rebeck', 'John Brancato', '']","['Action', 'Crime', 'Fantasy']","['Halle Berry', 'Sharon Stone', 'Benjamin Bratt']" 49 | 48,Kazaam,1996,PG,1.33,3.1,25,['Paul Michael Glaser'],"['Paul Michael Glaser', 'Christian Ford', 'Roger Soffer']","['Comedy', 'Family', 'Fantasy']","[""Shaquille O'Neal"", 'Francis Capra', 'Ally Walker']" 50 | 49,Student of the Year 2,2019,Not Rated,2.26,2.2,22,['Punit Malhotra'],"['Arshad Syed', 'Karan Johar']","['Action', 'Comedy', 'Drama']","['Tiger Shroff', 'Ananya Panday', 'Tara Sutaria']" 51 | 50,The Emoji Movie,2017,PG,1.26,3.4,69,['Tony Leondis'],"['Writers', 'Tony Leondis', 'Eric Siegel', 'Mike White', '']","['Animation', 'Adventure', 'Comedy']","['T.J. Miller', 'James Corden', 'Anna Faris']" 52 | 51,Vampires Suck,2010,PG-13,1.22,3.4,51,"['Jason Friedberg', 'Aaron Seltzer']","['Jason Friedberg', 'Aaron Seltzer']","['Comedy', 'Horror']","['Jenn Proske', 'Matt Lanter', 'Diedrich Bader']" 53 | 52,Steel,1997,PG-13,1.37,3.0,15,['Kenneth Johnson'],"['Louise Simonson', 'Jon Bogdanove', 'Kenneth Johnson']","['Action', 'Adventure', 'Crime']","[""Shaquille O'Neal"", 'Annabeth Gish', 'Judd Nelson']" 54 | 53,The Open House,2018,TV-MA,1.34,3.3,36,"['Matt Angel', 'Suzanne Coote']","['Matt Angel', 'Suzanne Coote']","['Horror', 'Thriller']","['Dylan Minnette', 'Piercey Dalton', 'Patricia Bethune']" 55 | 54,The Starving Games,2013,PG-13,1.23,3.2,22,"['Jason Friedberg', 'Aaron Seltzer']","['Jason Friedberg', 'Aaron Seltzer']","['Adventure', 'Comedy', 'Sci-Fi']","['Maiara Walsh', 'Brant Daugherty', 'Cody Christian']" 56 | 55,Laxmii,2020,TV-MA,2.21,2.5,58,"['Raghava Lawrence', 'Balakrishnan Thevar']","['Writers', 'Farhad Samji', 'Raghava Lawrence', 'Sparsh Khetarpal', '']","['Action', 'Comedy', 'Horror']","['Akshay Kumar', 'Kiara Advani', 'Sharad Kelkar']" 57 | 56,Breach,2020,R,1.32,2.9,19,['John Suits'],"['Edward Drake', 'Corey Large']","['Action', 'Horror', 'Sci-Fi']","['Cody Kearsley', 'Bruce Willis', 'Rachel Nichols']" 58 | 57,Tees Maar Khan,2010,Not Rated,2.15,2.6,14,['Farah Khan'],"['Writers', 'Vishal Dadlani', 'Anvita Dutt', 'Ashmith Kunder', '']","['Comedy', 'Crime']","['Akshay Kumar', 'Katrina Kaif', 'Akshaye Khanna']" 59 | 58,Scary Movie V,2013,PG-13,1.26,3.5,76,"['Malcolm D. Lee', 'David Zucker']","['Writers', 'David Zucker', 'Pat Proft', 'Shawn Wayans', '']","['Comedy', 'Horror']","['Simon Rex', 'Ashley Tisdale', 'Charlie Sheen']" 60 | 59,Dumb and Dumberer: When Harry Met Lloyd,2003,PG-13,1.25,3.4,42,['Troy Miller'],"['Writers', 'Peter Farrelly', 'Bennett Yellin', 'Bobby Farrelly', '']",['Comedy'],"['Derek Richardson', 'Eric Christian Olsen', 'Eugene Levy']" 61 | 60,Texas Chainsaw Massacre: The Next Generation,1994,R,1.27,3.3,25,['Kim Henkel'],"['Writers', 'Kim Henkel', 'Tobe Hooper', '']","['Comedy', 'Horror', 'Thriller']","['Renée Zellweger', 'Matthew McConaughey', 'Robert Jacks']" 62 | 61,Gunday,2014,Not Rated,2.32,2.7,60,['Ali Abbas Zafar'],"['Ali Abbas Zafar', 'Sanjay Masoomm']","['Action', 'Drama', 'Musical']","['Ranveer Singh', 'Arjun Kapoor', 'Priyanka Chopra Jonas']" 63 | 62,The Room,2003,R,1.39,3.6,94,['Tommy Wiseau'],['Tommy Wiseau'],['Drama'],"['Tommy Wiseau', 'Juliette Danielle', 'Greg Sestero']" 64 | 63,The Master of Disguise,2002,PG,1.2,3.3,27,['Perry Andelin Blake'],"['Dana Carvey', 'Harris Goldberg']","['Adventure', 'Comedy', 'Family']","['Dana Carvey', 'Jennifer Esposito', 'Harold Gould']" 65 | 64,Police Academy: Mission to Moscow,1994,PG,1.23,3.5,36,['Alan Metter'],"['Writers', 'Neal Israel', 'Pat Proft', 'Randolph Davis', '']","['Comedy', 'Crime']","['G.W. Bailey', 'George Gaynes', 'Michael Winslow']" 66 | 65,Daddy Day Camp,2007,PG,1.33,3.2,18,['Fred Savage'],"['Writers', 'Geoff Rodkey', 'J. David Stem', 'David N. Weiss', '']","['Comedy', 'Family']","['Cuba Gooding Jr.', 'Lochlyn Munro', 'Richard Gant']" 67 | 66,Bratz,2007,PG,1.5,3.1,25,['Sean McNamara'],"['Susan Estelle Jansen', 'Adam De La Peña', 'David Eilenberg']","['Comedy', 'Family', 'Music']","['Skyler Shaye', 'Janel Parrish', 'Logan Browning']" 68 | 67,Hercules in New York,1970,G,1.32,3.3,19,['Arthur Allan Seidelman'],['Aubrey Wisberg'],"['Adventure', 'Comedy', 'Fantasy']","['Arnold Stang', 'Arnold Schwarzenegger', 'Deborah Loomis']" 69 | 68,Far Cry,2008,R,1.35,3.2,15,['Uwe Boll'],"['Michael Roesch', 'Peter Scheerer', 'Masaji Takei']","['Action', 'Adventure', 'Sci-Fi']","['Til Schweiger', 'Emmanuelle Vaugier', 'Natalia Avelon']" 70 | 69,Mortal Kombat: Annihilation,1997,PG-13,1.35,3.6,57,['John R. Leonetti'],"['Writers', 'Ed Boon', 'Lawrence Kasanoff', 'Joshua Wexler', '']","['Action', 'Adventure', 'Fantasy']","['Robin Shou', 'Talisa Soto', 'James Remar']" 71 | 70,Feardotcom,2002,R,1.41,3.4,22,['William Malone'],"['Moshe Diamant', 'Josephine Coyle', 'Holly Payberg-Torroija']","['Crime', 'Horror', 'Thriller']","['Stephen Dorff', 'Natascha McElhone', 'Stephen Rea']" 72 | 71,Barb Wire,1996,R,1.38,3.5,31,['David Hogan'],"['Writers', 'Chris Warner', 'Ilene Chaiken', 'Chuck Pfarrer', '']","['Action', 'Sci-Fi']","['Pamela Anderson', 'Amir AboulEla', 'Adriana Alexander']" 73 | 72,Smolensk,2016,,0.0,1.2,40,['Antoni Krauze'],"['Writers', 'Antoni Krauze', 'Tomasz Lysiak', 'Maciej Pawlicki', '']","['Drama', 'Thriller']","['Beata Fido', 'Maciej Póltorak', 'Aldona Struzik']" 74 | 73,3 Ninjas: High Noon at Mega Mountain,1998,PG,1.33,2.9,12,['Sean McNamara'],"['Sean McNamara', 'Jeff Phillips']","['Action', 'Adventure', 'Comedy']","['Loni Anderson', 'Hulk Hogan', 'Jim Varney']" 75 | 74,Baaghi 3,2020,Not Rated,2.23,2.2,13,['Ahmed Khan'],"['Writers', 'Sajid Nadiadwala', 'Farhad Samji', 'Sparsh Khetarpal', '']","['Action', 'Adventure', 'Thriller']","['Tiger Shroff', 'Riteish Deshmukh', 'Shraddha Kapoor']" 76 | 75,Batman & Robin,1997,PG-13,0.25,3.8,264,['Joel Schumacher'],"['Bob Kane', 'Akiva Goldsman']","['Action', 'Sci-Fi']","['Arnold Schwarzenegger', 'George Clooney', ""Chris O'Donnell""]" 77 | 76,Fifty Shades of Black,2016,R,1.32,3.5,23,['Michael Tiddes'],"['Marlon Wayans', 'Rick Alvarez']",['Comedy'],"['Marlon Wayans', 'Kali Hawk', 'Fred Willard']" 78 | 77,Captain America,1990,PG-13,1.37,3.2,15,['Albert Pyun'],"['Writers', 'Joe Simon', 'Jack Kirby', 'Stephen Tolkin', '']","['Action', 'Adventure', 'Sci-Fi']","['Matt Salinger', 'Ronny Cox', 'Ned Beatty']" 79 | 78,Spy Kids 4: All the Time in the World,2011,PG,1.29,3.5,28,['Robert Rodriguez'],['Robert Rodriguez'],"['Action', 'Adventure', 'Comedy']","['Jessica Alba', 'Jeremy Piven', 'Joel McHale']" 80 | 79,The NeverEnding Story III,1994,G,1.35,3.2,12,['Peter MacDonald'],"['Jeff Lieberman', 'Karin Howard', 'Michael Ende']","['Adventure', 'Comedy', 'Family']","['Jason James Richter', 'Melody Kay', 'Jack Black']" 81 | 80,Crossroads,2002,PG-13,1.33,3.6,42,['Tamra Davis'],['Shonda Rhimes'],"['Comedy', 'Drama', 'Romance']","['Britney Spears', 'Anson Mount', 'Zoe Saldana']" 82 | 81,Jaws 3-D,1983,PG,1.39,3.7,47,['Joe Alves'],"['Writers', 'Peter Benchley', 'Richard Matheson', 'Carl Gottlieb', '']","['Adventure', 'Horror', 'Thriller']","['Dennis Quaid', 'Bess Armstrong', 'Simon MacCorkindale']" 83 | 82,Superman IV: The Quest for Peace,1987,PG,1.3,3.7,52,['Sidney J. Furie'],"['Writers', 'Jerry Siegel', 'Joe Shuster', 'Christopher Reeve', '']","['Action', 'Adventure', 'Sci-Fi']","['Christopher Reeve', 'Gene Hackman', 'Margot Kidder']" 84 | 83,Spice World,1997,PG,1.33,3.6,37,['Bob Spiers'],"['Writers', 'Spice Girls', 'Kim Fuller', 'Jamie Curtis', '']","['Comedy', 'Family', 'Music']","['Mel B', 'Emma Bunton', 'Melanie C']" 85 | 84,Dungeons & Dragons,2000,PG-13,1.47,3.6,36,['Courtney Solomon'],"['Topper Lilien', 'Carroll Cartwright', 'E. Gary Gygax']","['Action', 'Adventure', 'Fantasy']","['Justin Whalin', 'Jeremy Irons', 'Zoe McLellan']" 86 | 85,Black Christmas,2019,PG-13,1.32,3.5,18,['Sophia Takal'],"['Sophia Takal', 'April Wolfe', 'Roy Moore']","['Horror', 'Mystery', 'Thriller']","['Imogen Poots', 'Aleyse Shannon', 'Lily Donoghue']" 87 | 86,The Wicker Man,2006,PG-13,1.42,3.8,71,['Neil LaBute'],"['Neil LaBute', 'Anthony Shaffer']","['Horror', 'Mystery', 'Thriller']","['Nicolas Cage', 'Ellen Burstyn', 'Leelee Sobieski']" 88 | 87,The Fog,2005,PG-13,1.4,3.7,39,['Rupert Wainwright'],"['Cooper Layne', 'John Carpenter', 'Debra Hill']","['Horror', 'Mystery']","['Tom Welling', 'Maggie Grace', 'Selma Blair']" 89 | 88,Dragon Wars: D-War,2007,PG-13,1.47,3.5,25,['Hyung-rae Shim'],['Hyung-rae Shim'],"['Action', 'Drama', 'Fantasy']","['Jason Behr', 'Amanda Brooks', 'Robert Forster']" 90 | 89,I'll Always Know What You Did Last Summer,2006,R,1.32,3.4,13,['Sylvain White'],"['Lois Duncan', 'Michael D. Weiss']","['Horror', 'Mystery', 'Thriller']","['Brooke Nevin', 'David Paetkau', 'Torrey DeVitto']" 91 | 90,Mac and Me,1988,PG,1.39,3.4,14,['Stewart Raffill'],"['Stewart Raffill', 'Steve Feke']","['Adventure', 'Comedy', 'Family']","['Christine Ebersole', 'Jonathan Ward', 'Tina Caspary']" 92 | 91,Bucky Larson: Born to Be a Star,2011,R,1.37,3.3,13,['Tom Brady'],"['Adam Sandler', 'Allen Covert', 'Nick Swardson']",['Comedy'],"['Nick Swardson', 'Don Johnson', 'Christina Ricci']" 93 | 92,Goal! III,2009,PG-13,1.36,3.2,13,['Andrew Morahan'],"['Mike Jefferies', 'Piers Ashworth']","['Drama', 'Romance', 'Sport']","['JJ Feild', 'Leo Gregory', 'Kuno Becker']" 94 | 93,Piranha 3DD,2012,R,1.23,3.8,45,['John Gulager'],"['Writers', 'Patrick Melton', 'Marcus Dunstan', 'Joel Soisson', '']","['Comedy', 'Horror', 'Sci-Fi']","['Danielle Panabaker', 'Ving Rhames', 'David Hasselhoff']" 95 | 94,I Know Who Killed Me,2007,R,1.45,3.6,31,['Chris Sivertson'],['Jeff Hammond'],"['Horror', 'Mystery', 'Thriller']","['Lindsay Lohan', 'Julia Ormond', 'Neal McDonough']" 96 | 95,The Adventures of Sharkboy and Lavagirl 3-D,2005,PG,1.33,3.7,41,['Robert Rodriguez'],"['Robert Rodriguez', 'Marcel Rodriguez', 'Racer Rodriguez']","['Action', 'Adventure', 'Comedy']","['Cayden Boyd', 'George Lopez', 'Kristin Davis']" 97 | 96,The Love Guru,2008,PG-13,1.27,3.8,54,['Marco Schnabel'],"['Mike Myers', 'Graham Gordy']","['Comedy', 'Romance', 'Sport']","['Mike Myers', 'Jessica Alba', 'Romany Malco']" 98 | 97,The Hungover Games,2014,R,1.25,3.5,16,['Josh Stolberg'],"['Writers', 'Kyle Barnett Anderson', 'David Bernstein', 'Jamie Kennedy', '']","['Adventure', 'Comedy', 'Fantasy']","['Ben Begley', 'Herbert Russell', 'Ross Nathan']" 99 | 98,In the Name of the King: A Dungeon Siege Tale,2007,PG-13,0.27,3.8,51,['Uwe Boll'],"['Writers', 'Doug Taylor', 'Jason Rappaport', 'Dan Stroncak', '']","['Action', 'Adventure', 'Fantasy']","['Jason Statham', 'Ron Perlman', 'Ray Liotta']" 100 | 99,The Avengers,1998,PG-13,1.29,3.8,45,['Jeremiah S. Chechik'],"['Sydney Newman', 'Don MacPherson']","['Action', 'Adventure', 'Sci-Fi']","['Ralph Fiennes', 'Uma Thurman', 'Sean Connery']" 101 | 100,The Flintstones in Viva Rock Vegas,2000,PG,1.3,3.7,25,['Brian Levant'],"['Writers', 'William Hanna', 'Joseph Barbera', 'Deborah Kaplan', '']","['Comedy', 'Family', 'Romance']","['Mark Addy', 'Stephen Baldwin', 'Kristen Johnston']" 102 | -------------------------------------------------------------------------------- /machine_learning/naive_bayes.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """Naive_Bayes.py 3 | 4 | 5 | #Naive Bayes clasification . 6 | ## Project By: Aditya Ghosh 7 | [Linkedin](https://www.linkedin.com/in/adityaghosh2992/) [Github](https://github.com/aditya-ghosh2992) 8 | 9 | 10 | """ 11 | 12 | # Naive Bayes clasification . 13 | ## Make a ML program to predict the similarity 14 | 15 | # Sample Test : "__name__" and "__main__" 16 | 17 | import numpy as np 18 | 19 | class NaiveBayes: 20 | def fit(self, X, y): 21 | # Number of samples and features 22 | n_samples, n_features = X.shape 23 | # Get unique class labels 24 | self._classes = np.unique(y) 25 | n_classes = len(self._classes) 26 | 27 | # Initialize mean, variance, and prior probability for each class 28 | self._mean = np.zeros((n_classes, n_features), dtype=np.float64) 29 | self._var = np.zeros((n_classes, n_features), dtype=np.float64) 30 | self._priors = np.zeros(n_classes, dtype=np.float64) 31 | 32 | # Calculate statistics for each class 33 | for idx, c in enumerate(self._classes): 34 | X_c = X[y == c] # Samples belonging to class c 35 | self._mean[idx, :] = X_c.mean(axis=0) # Mean for each feature 36 | self._var[idx, :] = X_c.var(axis=0) # Variance for each feature 37 | self._priors[idx] = X_c.shape[0] / float(n_samples) # Prior probability 38 | 39 | def predict(self, X): 40 | # Predict class for each sample in X 41 | y_pred = [self._predict(x) for x in X] 42 | return np.array(y_pred) 43 | 44 | def _predict(self, x): 45 | # Calculate posterior probability for each class and choose the class with the highest probability 46 | posteriors = [] 47 | 48 | for idx, c in enumerate(self._classes): 49 | prior = np.log(self._priors[idx]) # Prior probability in log form 50 | posterior = np.sum(np.log(self._pdf(idx, x))) # Likelihood in log form 51 | posterior = prior + posterior # Posterior (log-prior + log-likelihood) 52 | posteriors.append(posterior) 53 | 54 | # Return the class with the highest posterior probability 55 | return self._classes[np.argmax(posteriors)] 56 | 57 | def _pdf(self, class_idx, x): 58 | # Probability Density Function (PDF) for Gaussian distribution 59 | mean = self._mean[class_idx] 60 | var = self._var[class_idx] 61 | numerator = np.exp(-((x - mean) ** 2) / (2 * var)) 62 | denominator = np.sqrt(2 * np.pi * var) 63 | return numerator / denominator 64 | 65 | 66 | # Testing the Naive Bayes classifier 67 | if __name__ == "__main__": 68 | # Imports 69 | from sklearn.model_selection import train_test_split 70 | from sklearn import datasets 71 | 72 | # Helper function to calculate accuracy 73 | def accuracy(y_true, y_pred): 74 | accuracy = np.sum(y_true == y_pred) / len(y_true) 75 | return accuracy 76 | 77 | # Generate a sample dataset 78 | X, y = datasets.make_classification( 79 | n_samples=1000, n_features=10, n_classes=2, random_state=123 80 | ) 81 | 82 | # Split data into training and test sets 83 | X_train, X_test, y_train, y_test = train_test_split( 84 | X, y, test_size=0.2, random_state=123 85 | ) 86 | 87 | # Initialize and train the Naive Bayes model 88 | nb = NaiveBayes() 89 | nb.fit(X_train, y_train) 90 | 91 | # Make predictions on the test set 92 | predictions = nb.predict(X_test) 93 | 94 | # Print accuracy 95 | print("Naive Bayes classification accuracy:", accuracy(y_test, predictions)) 96 | 97 | -------------------------------------------------------------------------------- /miscellaneous/file_handling_logging.py: -------------------------------------------------------------------------------- 1 | import logging 2 | 3 | # Configure logging 4 | logging.basicConfig(filename='app.log', level=logging.INFO, 5 | format='%(asctime)s - %(levelname)s - %(message)s') 6 | 7 | # Create a sample text file and write content to it 8 | filename = 'sample_file.txt' 9 | 10 | # Write some content to the file 11 | with open(filename, 'w') as file: 12 | file.write("Hello, World!\nWelcome to the world of Python file handling.\n") 13 | logging.info(f'File {filename} created and content written successfully.') 14 | 15 | # Read content from the file and print it 16 | try: 17 | with open(filename, 'r') as file: 18 | content = file.read() 19 | logging.info(f'Content read from {filename}: \n{content}') 20 | print(content) 21 | except FileNotFoundError: 22 | logging.error(f"File {filename} not found.") 23 | except Exception as e: 24 | logging.error(f"An error occurred while reading the file: {e}") 25 | --------------------------------------------------------------------------------