Upload 10 files

Untitled-1.ipynb

@@ -0,0 +1,101 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Test MSE:  1.9502589114484195\n",
+      "0.9252566690286127\n"
+     ]
+    }
+   ],
+   "source": [
+    "import pandas as pd\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "from sklearn.ensemble import HistGradientBoostingRegressor\n",
+    "from sklearn.metrics import mean_squared_error,r2_score\n",
+    "import pickle\n",
+    "\n",
+    "# Load the dataset from CSV\n",
+    "selected_columns = ['Process type', 'Part Od', 'Part ID', 'Part Width', 'Finish Wt', 'Input Weight']\n",
+    "data = pd.read_csv('/Users/abhijay/Desktop/EY_INTERNSHIP/Data_4.csv', usecols=selected_columns)\n",
+    "\n",
+    "# Assuming 'Input Weight' is the target variable, and other columns are features\n",
+    "X = data.drop(columns=['Input Weight'])\n",
+    "y = data['Input Weight']\n",
+    "\n",
+    "# Split the data into training and testing sets (80% train, 20% test)\n",
+    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n",
+    "\n",
+    "from sklearn.model_selection import RandomizedSearchCV\n",
+    "from scipy.stats import uniform, randint\n",
+    "\n",
+    "# Define the parameter grid\n",
+    "param_dist = {\n",
+    "    'learning_rate': uniform(0.01, 0.2),\n",
+    "    'max_iter': randint(100, 1000),\n",
+    "    'max_leaf_nodes': randint(10, 50),\n",
+    "    'max_depth': randint(3, 10),\n",
+    "    'min_samples_leaf': randint(1, 20),\n",
+    "    'max_bins': randint(50, 256),\n",
+    "    'l2_regularization': uniform(0, 1),\n",
+    "    'early_stopping': [True, False]\n",
+    "}\n",
+    "\n",
+    "# Instantiate the model\n",
+    "model = HistGradientBoostingRegressor()\n",
+    "\n",
+    "# Instantiate the RandomizedSearchCV object\n",
+    "random_search = RandomizedSearchCV(model, param_distributions=param_dist, n_iter=100, cv=5, random_state=42, n_jobs=-1)\n",
+    "\n",
+    "# Fit the random search model\n",
+    "random_search.fit(X_train, y_train)\n",
+    "\n",
+    "# Get the best estimator\n",
+    "best_model = random_search.best_estimator_\n",
+    "\n",
+    "# Use the best model to predict on the test set\n",
+    "y_pred = best_model.predict(X_test)\n",
+    "\n",
+    "\n",
+    "\n",
+    "\n",
+    "from sklearn.metrics import mean_squared_error\n",
+    "mse_test = mean_squared_error(y_test, y_pred)\n",
+    "r_square=r2_score(y_test, y_pred)\n",
+    "print(\"Test MSE: \", mse_test)\n",
+    "print(r_square)\n",
+    "\n",
+    "\n",
+    "with open('best_model.pkl', 'wb') as model_file:\n",
+    "    pickle.dump(best_model, model_file)\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "base",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

Untitled-2.ipynb

@@ -0,0 +1,75 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Machining Time Test MSE: 1.0179070252739131e-11\n"
+     ]
+    }
+   ],
+   "source": [
+    "import pandas as pd\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "from sklearn.ensemble import HistGradientBoostingRegressor\n",
+    "from sklearn.metrics import mean_squared_error\n",
+    "import pickle\n",
+    "\n",
+    "# Load the dataset from CSV\n",
+    "selected_columns = ['Process type', 'Part Od', 'Part ID', 'Part Width', 'Finish Wt', 'Input Weight',\n",
+    "                    'Raw material cost', 'Process cost', 'Machining Time']  # Add more columns as needed\n",
+    "data = pd.read_csv('/Users/abhijay/Desktop/EY_INTERNSHIP/Data_4.csv', usecols=selected_columns)  # Replace 'your_dataset.csv' with the path to your CSV file\n",
+    "\n",
+    "# For predicting machining time, assume 'Machining Time' is the target variable\n",
+    "X_machining = data.drop(columns=['Machining Time'])\n",
+    "y_machining = data['Machining Time']\n",
+    "\n",
+    "# Split the data for machining time into training and testing sets (80% train, 20% test)\n",
+    "X_machining_train, X_machining_test, y_machining_train, y_machining_test = train_test_split(X_machining, y_machining, test_size=0.2, random_state=42)\n",
+    "\n",
+    "# Train the model for machining time\n",
+    "model_machining = HistGradientBoostingRegressor()\n",
+    "model_machining.fit(X_machining_train, y_machining_train)\n",
+    "\n",
+    "# Evaluate the model\n",
+    "\n",
+    "test_predictions_machining = model_machining.predict(X_machining_test)\n",
+    "\n",
+    "test_mse_machining = mean_squared_error(y_machining_test, test_predictions_machining)\n",
+    "\n",
+    "\n",
+    "print(\"Machining Time Test MSE:\", test_mse_machining)\n",
+    "\n",
+    "# Save the model to disk\n",
+    "with open('machining_model.pkl', 'wb') as model_file:\n",
+    "    pickle.dump(model_machining, model_file)\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "base",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

Untitled-3.ipynb

@@ -0,0 +1,73 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Inspection Time Test MSE: 4.0716280667897373e-13\n"
+     ]
+    }
+   ],
+   "source": [
+    "import pandas as pd\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "from sklearn.ensemble import HistGradientBoostingRegressor\n",
+    "from sklearn.metrics import mean_squared_error\n",
+    "import pickle\n",
+    "# Load the dataset from CSV\n",
+    "selected_columns = ['Process type', 'Part Od', 'Part ID', 'Part Width', 'Finish Wt', 'Input Weight',\n",
+    "                    'Raw material cost', 'Process cost', 'Machining Time', 'Machining cost ', 'Inspection Time']  # Add more columns as needed\n",
+    "data = pd.read_csv('/Users/abhijay/Desktop/EY_INTERNSHIP/Data_4.csv', usecols=selected_columns)  # Replace 'your_dataset.csv' with the path to your CSV file\n",
+    "\n",
+    "# For predicting inspection time, assume 'Inspection Time' is the target variable\n",
+    "X_inspection = data.drop(columns=['Inspection Time'])\n",
+    "y_inspection = data['Inspection Time']\n",
+    "\n",
+    "# Split the data for inspection time into training and testing sets (80% train, 20% test)\n",
+    "X_inspection_train, X_inspection_test, y_inspection_train, y_inspection_test = train_test_split(X_inspection, y_inspection, test_size=0.2, random_state=42)\n",
+    "\n",
+    "# Train the model for inspection time\n",
+    "model_inspection = HistGradientBoostingRegressor()\n",
+    "model_inspection.fit(X_inspection_train, y_inspection_train)\n",
+    "\n",
+    "# Evaluate the model\n",
+    "\n",
+    "test_predictions_inspection = model_inspection.predict(X_inspection_test)\n",
+    "\n",
+    "test_mse_inspection = mean_squared_error(y_inspection_test, test_predictions_inspection)\n",
+    "\n",
+    "print(\"Inspection Time Test MSE:\", test_mse_inspection)\n",
+    "\n",
+    "# Save the model to disk\n",
+    "with open('inspection_model.pkl', 'wb') as model_file:\n",
+    "    pickle.dump(model_inspection, model_file)\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "base",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

app (2).py

@@ -0,0 +1,174 @@
+import streamlit as st
+import pandas as pd
+import pickle
+import os
+from database import create_connection, initialize_database, insert_data, fetch_data
+
+# Database setup
+conn = create_connection('example.db')
+initialize_database(conn)
+
+# Load the trained models
+current_dir = os.path.dirname(os.path.abspath(__file__))
+
+with open(os.path.join(current_dir, 'best_model.pkl'), 'rb') as model_file:
+    input_weight_model = pickle.load(model_file)
+with open(os.path.join(current_dir, 'machining_model.pkl'), 'rb') as model_file:
+    machining_model = pickle.load(model_file)
+with open(os.path.join(current_dir, 'inspection_model.pkl'), 'rb') as model_file:
+    inspection_model = pickle.load(model_file)
+
+# Final landed cost based on grade type
+final_landed_cost = {
+    '1  MT  XX (25-95 dia)': 103,
+    '1  MT  XX (100-210 dia)': 113,
+    '1  MT YY (25-95 dia)': 160,
+    '1  MT  YY (100-125 dia)': 173,
+    '1  MT  XY (25-95 dia))': 106,
+    '1  MT  8319 (100-210 dia)':116,
+    '1  MT  8319':104
+}
+
+# Function to calculate raw material cost
+def calculate_raw_material_cost(process_type, input_weight, grade_type):
+    if process_type == 0:  # 0 represents casting
+        return 0
+    elif process_type == 1:  # 1 represents forging
+        return input_weight * final_landed_cost[grade_type]
+
+# Function to calculate process cost
+def calculate_process_cost(process_type, input_weight):
+    if process_type == 0:  # 0 represents casting
+        return (input_weight * (120.57788 / 1000) * 1000)
+    elif process_type == 1:  # 1 represents forging
+        return input_weight * 30
+
+# Streamlit interface
+st.title("EX-Works Calculator")
+
+# Page navigation
+pages = ["Home", "Vendor Data", "Material Data", "RM Cost Data", "Supplier Data"]
+page = st.sidebar.selectbox("Select Page", pages)
+
+if page == "Home":
+    st.write("Welcome to the EX-Works Calculator application.")
+
+elif page == "Vendor Data":
+    st.header("Vendor Data")
+    vendor_name = st.text_input("Vendor Name")
+    vendor_type = st.text_input("Vendor Type")
+    gst_no =st.number_input("GST NO")
+    contact_person_name=st.text_input("CONTACT PERSON/NAME")
+    address=st.text_input("ADDRESS")
+    city=st.text_input("CITY")
+    panno=st.text_input("PAN NO")
+    
+    if st.button("Add Vendor"):
+        vendor_data = pd.DataFrame({'vendor_name': [vendor_name], 'vendor_type': [vendor_type], 'GST_NO': [gst_no], 'Contact_person_name': [contact_person_name], 'address': [address], 'city': [city], 'pan_no':[panno]})
+        insert_data(conn, 'vendor_data', vendor_data)
+        st.success("Vendor data added successfully")
+
+elif page == "Material Data":
+    st.header("Material Data")
+    part_id = st.number_input("Part ID")
+    part_no = st.number_input("Part Number")
+    scf = st.selectbox("SCF", options=[0, 1])
+    process_type = st.selectbox("Process Type", options=[0, 1])
+    part_od = st.number_input("Part Outer Dimension")
+    part_width = st.number_input("Part Width")
+    part_inner_dimension = st.number_input("Part Inner Dimension")
+    material_spec = st.selectbox("Material Specification", options=[0, 1])
+    finish_wt = st.number_input("Finish Weight")
+    green_drg_no = st.selectbox("Green DRG Number", options=[0, 1])
+    
+    if st.button("Add Material"):
+        material_data = pd.DataFrame({'Part_id': [part_id],'part_no': [part_no], 'scf': [scf],'process_type': [process_type],'part_od': [part_od],'part_width': [part_width],'part_inner_dimension': [part_inner_dimension],'material_specification': [material_spec],'finish_wt': [finish_wt],'green_drg_no': [green_drg_no]})
+        insert_data(conn, 'material_data', material_data)
+        st.success("Material data added successfully")
+
+
+elif page == "RM Cost Data":
+    st.header("RM Cost Data")
+    rm_type = st.text_input("RM Type")
+    rm_cost = st.number_input("RM Cost", min_value=0.0, step=0.01)
+    vendor_id = st.number_input("Vendor ID", min_value=1, step=1)
+    
+    if st.button("Add RM Cost Data"):
+        rm_cost_data = pd.DataFrame({'rm_type': [rm_type], 'rm_cost': [rm_cost], 'vendor_id': [vendor_id]})
+        insert_data(conn, 'rm_cost_data', rm_cost_data)
+        st.success("RM cost data added successfully")
+
+elif page == "Supplier Data":
+    st.header("Supplier Data")
+    part_no = st.number_input("Part No", min_value=1, step=1)
+    process_type = st.selectbox("Process Type", options=[0, 1])
+    part_od = st.number_input("Part OD", min_value=0.0, step=0.1)
+    part_id = st.number_input("Part ID", min_value=0.0, step=0.1)
+    part_width = st.number_input("Part Width", min_value=0, step=1)
+    finish_wt = st.number_input("Finish Wt", min_value=0.0, step=0.1)
+    grade_type = st.selectbox("Grade Type", options=list(final_landed_cost.keys()))
+    material_id = st.number_input("Material ID", min_value=1, step=1)
+    
+    if st.button("Calculate and Add Supplier Data"):
+        # Prepare the input data for prediction
+        input_data = pd.DataFrame({
+            'Process type': [process_type],
+            'Part Od': [part_od],
+            'Part ID': [part_id],
+            'Part Width': [part_width],
+            'Finish Wt': [finish_wt]
+        })
+
+        # Predict the input weight
+        predicted_input_weight = input_weight_model.predict(input_data)[0]
+
+        # Calculate raw material cost
+        raw_material_cost = calculate_raw_material_cost(process_type, predicted_input_weight, grade_type)
+        
+        # Calculate process cost
+        process_cost = calculate_process_cost(process_type, predicted_input_weight)
+        
+        # Prepare the data for machining time prediction
+        machining_data = pd.DataFrame({
+            'Process type': [process_type],
+            'Part Od': [part_od],
+            'Part ID': [part_id],
+            'Part Width': [part_width],
+            'Finish Wt': [finish_wt],
+            'Input Weight': [predicted_input_weight],
+            'Raw material cost': [raw_material_cost],
+            'Process cost': [process_cost]
+        })
+
+        # Predict the machining time
+        predicted_machining_time = machining_model.predict(machining_data)[0]
+
+        # Calculate machining cost
+        machining_cost = predicted_machining_time * 375.71
+        
+        # Calculate scrap recovery
+        scrap_recovery = (predicted_input_weight - finish_wt) * 11.5
+        
+        # Prepare the data for inspection time prediction
+        inspection_data = pd.DataFrame({
+            'Process type': [process_type],
+            'Part Od': [part_od],
+            'Part ID': [part_id],
+            'Part Width': [part_width],
+            'Finish Wt': [finish_wt],
+            'Input Weight': [predicted_input_weight],
+            'Raw material cost': [raw_material_cost],
+            'Process cost': [process_cost],
+            'Machining Time': [predicted_machining_time],
+            'Machining cost': [machining_cost],
+            'Scrap recovery': [scrap_recovery]
+        })
+
+        # Predict the inspection time
+        predicted_inspection_time = inspection_model.predict(inspection_data)[0]
+
+        # Calculate inspection cost
+        inspection_cost = predicted_inspection_time * 375.71
+        
+        # Calculate total mg cost
+        total_mg_cost = raw_material_cost + process_cost + machining_cost + scrap_recovery + inspection

best_model.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3892c1949117792f374863ca4257ef20e1f6844e59bc74afbb582fdb2a05fe14
+size 59325

database (1).py

@@ -0,0 +1,58 @@
+import sqlite3
+import pandas as pd
+
+def create_connection(db_file):
+    """Create a database connection to the SQLite database."""
+    conn = sqlite3.connect(db_file)
+    return conn
+
+def initialize_database(conn):
+    """Initialize the database with tables and constraints."""
+    with conn:
+        conn.execute('''CREATE TABLE IF NOT EXISTS vendor_data (
+                            vendor_type TEXT NOT NULL,
+                            vendor_name TEXT PRIMARY KEY,
+                            GST_NO INTEGER NOT NULL,
+                            Contact_person_name TEXT NOT NULL,
+                            address TEXT NOT NULL,
+                            city TEXT NOT NULL,
+                            pan_no TEXT NOT NULL CHECK(length(pan_no) <= 10)
+                        )''')
+        
+        conn.execute('''CREATE TABLE IF NOT EXISTS material_data (
+                            Part_id INTEGER PRIMARY KEY AUTOINCREMENT,
+                            part_no INTEGER NOT NULL,
+                            scf TEXT NOT NULL,
+                            process_type TEXT NOT NULL,
+                            part_od REAL NOT NULL,
+                            part_width INTEGER NOT NULL,
+                            part_inner_dimension REAL NOT NULL,
+                            material_specification TEXT NOT NULL,
+                            finish_wt REAL NOT NULL,
+                            green_drg_no INTEGER NOT NULL
+                        )''')
+        
+        conn.execute('''CREATE TABLE IF NOT EXISTS rm_cost_data (
+                            grade_type TEXT NOT NULL,
+                            usd_cif REAL NOT NULL,
+                            rate REAL NOT NULL,
+                            final_landed_cost REAL
+                        )''')
+        
+        conn.execute('''CREATE TABLE IF NOT EXISTS supplier_data (
+                            input_weight REAL,
+                            process_code TEXT,
+                            machining_time REAL,
+                            inspection_time REAL,
+                            process_cost REAL,
+                            machining_cost REAL,
+                            inspection_cost REAL
+                        )''')
+
+def insert_data(conn, table, data):
+    """Insert data into SQLite database."""
+    data.to_sql(table, conn, if_exists='append', index=False)
+
+def fetch_data(query, conn):
+    """Fetch data from SQLite database."""
+    return pd.read_sql_query(query, conn)

inspection_model.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2ff7355298024e9f4ed93d65a428bb4714bcf66d30d385a45f34ebb22a7465ce
+size 35374

machining_model.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b4034770f0a2a9059ec948eb8b16e09a18b6d28ffcf79137c83ec446b0ba70a1
+size 34353

model.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a559e548fd44ecd683f11b9476b7b4c5fd68681a4fb81fb72039b40bb115d968
+size 515

requirements.txt

@@ -0,0 +1,4 @@
+streamlit==1.32.2
+pandas==1.5.3
+scikit-learn==1.2.2
+