Upload 11 files

Retrain_Crop_Recommendation.py

@@ -0,0 +1,38 @@
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+import seaborn as sns
+from sklearn.metrics import confusion_matrix,classification_report,accuracy_score
+from sklearn.model_selection import train_test_split, GridSearchCV,RandomizedSearchCV
+from sklearn.preprocessing import OrdinalEncoder,LabelEncoder,OneHotEncoder
+from sklearn.ensemble import RandomForestClassifier
+import pickle
+def crop_reco():
+
+
+    df = pd.read_csv('Crop_recommendation.csv')
+
+    from sklearn.preprocessing import LabelEncoder
+    le = LabelEncoder()
+    df['label'] = le.fit_transform(df['label'])
+
+    class_labels = le.classes_
+
+    x = df.drop('label',axis=1)
+    y = df['label']
+
+    X_train,X_test,y_train,y_test = train_test_split(x,y,test_size=0.10,shuffle=True)
+
+    rf = RandomForestClassifier()
+    param_grid = {'n_estimators':np.arange(50,200),
+        'criterion':['gini','entropy'],
+        'max_depth':np.arange(2,25),
+        'min_samples_split':np.arange(2,25),
+        'min_samples_leaf':np.arange(2,25)}
+
+    rscv_model = RandomizedSearchCV(rf,param_grid, cv=5)
+    rscv_model.fit(X_train,y_train)
+
+    best_rf_model = rscv_model.best_estimator_
+    pickle.dump(best_rf_model, open("crop_recommendation.pickle","wb"))
+

Soli_to_recommandation_model_Raghuu.pkl

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

Soli_to_recommandation_model_Simha.pkl

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

Weather_app.py

@@ -0,0 +1,150 @@
+import requests
+import streamlit as st
+import time
+import math
+import pickle as pk
+import seaborn as sns 
+import matplotlib.pyplot as plt
+import pandas as pd 
+import numpy as np
+import streamlit as st
+import plotly.express as px
+import pandas as pd
+
+def get_weather_details(city_name):
+    base_url = "https://api.openweathermap.org/data/2.5/weather"
+    params = {
+        'q': city_name,
+        'appid': "d73ec4f18aca81c32b1836a8ac2506e0"
+    }
+
+    try:
+        response = requests.get(base_url, params=params)
+        data = response.json()
+
+        # Check if the request was successful
+        if response.status_code == 200:
+            # Extract weather details
+            weather_details = {
+                'city': city_name,
+                'temperature': data['main']['temp'],
+                'description': data['weather'][0]['description'],
+                'humidity': data['main']['humidity'],
+                'wind_speed': data['wind']['speed']
+            }
+            return weather_details
+        else:
+            st.write("Error {}: {}".format(response.status_code, data['message']))
+            return None
+    except Exception as e:
+        st.write("An error occurred:", e)
+        return None
+
+# -------------------------------------------------------------------------------------------Api---------------------------------------------------------
+# Replace with your actual values
+def run_weather_app():
+    st.title("City Weather Overview")
+    try:
+        global city_name
+        city_name = st.selectbox('Enter City',("Bagalkot", "Ballari", "Belagavi", "Bidar", "Chikkaballapur", "Chikkamagaluru", "Chitradurga", "Davanagere", "Dharwad", "Gadag", "Hassan", "Haveri", "Kalaburagi", "Kodagu", "Kolar", "Koppal", "Mandya", "Mysuru", "Raichur", "Ramanagara", "Shivamogga", "Tumakuru", "Udupi", "Uttara Kannada", "Vijayapura","Yadgir"),key="unique_key_2")
+        
+        if city_name:
+            # api_key = "d73ec4f18aca81c32b1836a8ac2506e0"
+
+            # Get weather details
+            prediction = ''
+            if st.button('Show'):
+                progress = st.progress(0)
+                for i in range(100):
+                    time.sleep(0.005)
+                    progress.progress(i+1)
+
+                weather_data = get_weather_details(city_name)
+                if weather_data:
+                    column1, column2 = st.columns(2)
+                    column1.metric("City", weather_data['city'].capitalize())
+                    column1.metric("Temperature",value=f"{ round(weather_data['temperature'] - 273.15, 2) } °C",delta= weather_data['description'])
+                    # column1.metric("Description", weather_data['description'])
+                    column1.metric("Humidity",value= f"{weather_data['humidity']} %")
+                    column1.metric("Wind Speed",value= f"{math.ceil(weather_data['wind_speed']*3.6)} km/hr")
+        else:
+            st.error("Invalid City Name")
+
+    except Exception as e:
+        st.error("An error occurred:", e)
+
+    return None
+###-------------------------------------------------------------------Current weather------------------------------------------------------------
+forecast_model = pk.load(open('rain_forecast_model.pkl','rb'))
+
+def run_forecast():
+    global forecast_data
+    num_months = st.number_input('Enter the number of months to forecast', min_value=1, max_value=48, value=1, step=1)
+    # st.write(num_months)
+    forecast_data = forecast_model.forecast(steps = 12+num_months)
+    st.title('Monthly Rainfall Overview')
+    df = pd.DataFrame({'Month': forecast_data.index.strftime('%Y-%m'), 'Values': np.round(forecast_data.values, 2)})
+    # Plotly bar chart with hover information
+    fig = px.bar(df, x='Month', y='Values', text='Values', color='Values',
+                labels={'Values': 'Precipitation'},
+                title='Monthly Forecast Data',
+                template='plotly',
+                color_continuous_scale='viridis')
+    # Set hover text to rounded values
+    fig.update_traces(texttemplate='%{text:.2f}', textposition='outside')
+    # Customize x-axis labels
+    # fig.update_xaxes(tickangle=45)
+    # Display the plot in Streamlit
+    st.plotly_chart(fig)
+
+#-----------------------------------------------------------------------------------------------------------------------------
+
+def india_precipitation():
+    st.title('India Monthly Precipitation')
+
+    data = pd.DataFrame({'Month': forecast_data.index.strftime('%Y-%m'), 'Precipitation': np.round(forecast_data.values, 2)})
+    
+    fig = px.choropleth(data, locations=["India"] * len(data), 
+                        locationmode="country names",
+                        color='Precipitation',
+                        hover_name='Month',
+                        animation_frame='Month',  # Use 'Month' as the animation frame
+                        range_color=[forecast_data.min(), forecast_data.max()],  # Adjust the range
+                        color_continuous_scale='Viridis'
+                        )
+    
+    st.plotly_chart(fig)
+
+    
+#--------------------------------------------------------------------------------------------------------------------------
+
+def forecast_data_for_tab():
+    forecast_df = pd.DataFrame()
+    forecast_df['Months'] = forecast_data.index.strftime('%Y-%m')
+    forecast_df['Precipitation'] = forecast_data.values
+    st.table(forecast_df)
+
+    # Add a download button for CSV
+    csv_button = st.download_button(
+        label="Download Forecast Data as CSV",
+        data=forecast_df.to_csv(index=False).encode('utf-8'),
+        file_name='forecast_data.csv',
+        mime='text/csv'
+    )
+    
+#----------------------------------------------------------------------------------------------------------------
+
+def weather_forecast_app():
+    # st.set_page_config(page_title="Weather App", page_icon=":cloud:")
+    if True:
+        run_weather_app()
+    if True:    
+        tab1, tab2, tab3 = st.tabs(['Forecast Barplot', 'Forecast data', 'Map'])    
+        with tab1:
+            run_forecast()
+        with tab2:
+            forecast_data_for_tab()
+        with tab3:
+            india_precipitation()
+            
+

retrain_Crop_yield.py

@@ -0,0 +1,43 @@
+
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+import warnings
+import pickle
+warnings.filterwarnings('ignore')
+
+def Crop_yel():
+    data = pd.read_csv('crop_yield.csv')
+
+    columns = ['Crop', 'Season', 'State']
+    from sklearn.preprocessing import LabelEncoder
+    encoder = LabelEncoder()
+    for col in columns:
+        data[col] = encoder.fit_transform(data[col])
+
+    X = data.iloc[:,:-1]
+    y = data.iloc[:,-1]
+
+    from sklearn.model_selection import train_test_split
+    X_train, X_test, y_train, y_test = train_test_split(X, y, random_state= 42, test_size= 0.2)
+
+    from sklearn.ensemble import ExtraTreesRegressor
+    from sklearn.metrics import r2_score
+
+    model = ExtraTreesRegressor(
+        n_estimators=200,
+        criterion='squared_error',  
+        max_depth=20,
+        min_samples_split=2,
+        min_samples_leaf=1,
+        max_features=5,
+        bootstrap=True,
+        random_state=42
+    )
+
+
+    model.fit(X_train, y_train)
+    pickle.dump(model,open('crop_yield_model.pkl','wb'))
+
+

retrain_gross_premium.py

@@ -0,0 +1,69 @@
+def grop():
+    from sklearn.ensemble import ExtraTreesRegressor
+    from sklearn.model_selection import train_test_split
+    from sklearn.preprocessing import StandardScaler
+    from sklearn.pipeline import Pipeline
+    from sklearn.compose import ColumnTransformer
+    from sklearn.preprocessing import LabelEncoder
+    import pandas as pd
+    data = pd.read_csv('insurance.csv')
+    data_new = data.copy(deep = True)
+    data.head()
+    data.isnull().sum()
+    data.dropna(inplace = True)
+    X = data.drop('gross_premium', axis = 1)
+    y = data['gross_premium']
+    import re
+
+    obj_columns = list(data.select_dtypes("object").columns)
+    obj_columns
+    import re
+
+    for col in obj_columns:
+        data[col] = data[col].astype("str")
+        data[col] = data[col].apply(lambda x: re.sub(r'[^a-zA-Z0-9]', '', x.lower())).astype("str")
+    data.head()
+    season_catogory = list(data.season.values)
+    scheme_catogory = list(data.scheme.values)
+    state_catogory  = list(data.state_name.values)
+    district_catogory = list(data.district_name.values)
+    columns = ['season','scheme','state_name','district_name']
+    from sklearn.preprocessing import LabelEncoder
+    encoder = LabelEncoder()
+    for col in columns:
+        data[col] = encoder.fit_transform(data[col])
+    season_label = list(data.season.values)
+    scheme_label = list(data.scheme.values)
+    state_label = list(data.state_name.values)
+    district_label = list(data.district_name.values)
+    season_category_label_dict = dict(zip(season_catogory, season_label))
+
+    scheme_category_label_dict = dict(zip(scheme_catogory, scheme_label))
+
+    state_category_label_dict = dict(zip(state_catogory, state_label))
+
+    district_category_label_dict = dict(zip(district_catogory, district_label))
+    data.season.value_counts()
+    X = data.iloc[:,:-1]
+    y = data.iloc[:,-1]
+    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+    from sklearn.linear_model import LinearRegression
+    model = LinearRegression()
+    model.fit(X_train, y_train)
+    from sklearn.metrics import r2_score
+    y_pred = model.predict(X_test)
+    r2 = r2_score(y_test, y_pred)
+    print(f'R2 Score: {round(r2*100, 2)}')
+    y_pred = model.predict(X_train)
+    r2 = r2_score(y_train, y_pred)
+    print(f'R2 Score: {round(r2*100, 2)}')
+    # There is no miss prediction hence model is not overfitted.........(i.e if its is overfitted than we use regularzation technique)
+    import pickle as pk
+    filename= 'crop_grosspremimum_Jp.pkl'
+    pk.dump(model,open(filename,'wb'))
+    def encoding(input_data):
+        input_data[0] = season_category_label_dict[input_data[0].lower().replace(" ","").replace(" ","").replace(" ","").replace(" ","")]
+        input_data[1] = scheme_category_label_dict[input_data[1].lower().replace(" ","").replace(" ","").replace(" ","").replace(" ","")]
+        input_data[2] = state_category_label_dict[input_data[2].lower().replace(" ","").replace(" ","").replace(" ","").replace(" ","")]
+        input_data[3] = district_category_label_dict[input_data[3].lower().replace(" ","").replace(" ","").replace(" ","").replace(" ","")]
+        return input_data

retrain_save_soil.py

@@ -0,0 +1,75 @@
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+import pandas as pd
+import pickle
+from sklearn.model_selection import train_test_split, GridSearchCV
+from sklearn.preprocessing import StandardScaler
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.metrics import classification_report, accuracy_score
+def soil_model():
+
+    data = pd.read_csv("Cr3.csv")
+
+
+
+    import re
+
+    obj_columns = data.select_dtypes("object")
+
+    for col in obj_columns:
+        data[col] = data[col].apply(lambda x: re.sub(r'[^a-zA-Z0-9]', '', x.lower())).astype("str")
+
+
+
+    data.head()
+
+    from sklearn.preprocessing import LabelEncoder
+
+    le = LabelEncoder()
+    data["Plant"] = le.fit_transform(data["Plant"])
+
+    # Assuming 'data' is your DataFrame
+    # If 'data' is not defined, make sure to load or create your dataset
+
+    X = data.drop('Plant', axis=1)
+    y = data['Plant']
+
+    # Split the data into training and testing sets
+    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+
+    # Standardize the training and testing sets using StandardScaler
+    scaler = StandardScaler()
+    X_train_scaled = scaler.fit_transform(X_train)
+    X_test_scaled = scaler.transform(X_test)
+
+    # Hyperparameter search for RandomForestClassifier
+    param_grid = {
+        'n_estimators': [50, 100, 200],
+        'max_depth': [None, 10, 20],
+        'min_samples_split': [2, 5, 10],
+        'min_samples_leaf': [1, 2, 4]
+    }
+    rf_classifier = RandomForestClassifier(random_state=42)
+    grid_search =GridSearchCV(rf_classifier, param_grid, cv=5, scoring='accuracy', n_jobs=-1)
+    grid_search.fit(X_train_scaled, y_train)
+
+    # Get the best parameters and the best estimator
+    best_params = grid_search.best_params_
+    best_rf_classifier = grid_search.best_estimator_
+
+    # Fit the final model with the best parameters on the entire dataset
+    final_rf_classifier = RandomForestClassifier(**best_params, random_state=42)
+    final_rf_classifier.fit(X, y)
+    pickle.dump(final_rf_classifier,open('Soli_to_recommandation_model_Raghuu.pkl','wb'))
+    # return final_rf_classifier
+
+
+
+
+
+
+
+
+

retrain_sum_insured.py

@@ -0,0 +1,75 @@
+def sumin():
+    import pandas as pd
+    import numpy as np
+    data = pd.read_csv("insurance(R).csv")
+    data_new = data.copy(deep = True)
+
+    import re
+
+    obj_columns = data.select_dtypes("object")
+
+    for col in obj_columns:
+        data[col] = data[col].apply(lambda x: re.sub(r'[^a-zA-Z0-9]', '', x.lower())).astype("str")
+    data.head()
+    season_catogory = list(data.season.values)
+    scheme_catogory = list(data.scheme.values)
+    state_catogory  = list(data.state_name.values)
+    district_catogory = list(data.district_name.values)
+    columns = ['season','scheme','state_name','district_name']
+    from sklearn.preprocessing import LabelEncoder
+    encoder = LabelEncoder()
+    for col in columns:
+        data[col] = encoder.fit_transform(data[col])
+    season_label = list(data.season.values)
+    scheme_label = list(data.scheme.values)
+    state_label = list(data.state_name.values)
+    district_label = list(data.district_name.values)
+    season_category_label_dict = dict(zip(season_catogory, season_label))
+
+    scheme_category_label_dict = dict(zip(scheme_catogory, scheme_label))
+
+    state_category_label_dict = dict(zip(state_catogory, state_label))
+
+    district_category_label_dict = dict(zip(district_catogory, district_label))
+
+    from sklearn.compose import ColumnTransformer
+    from sklearn.ensemble import ExtraTreesRegressor
+    from sklearn.pipeline import Pipeline
+    from sklearn.preprocessing import LabelEncoder, StandardScaler, FunctionTransformer
+    from sklearn.model_selection import train_test_split
+    X = data.drop("sum_insured", axis=1)
+    y = data["sum_insured"]
+    X_train, X_test, y_train, y_test = train_test_split(X,y, random_state=1000, test_size=0.2)
+    from sklearn.ensemble import ExtraTreesRegressor
+    from sklearn.metrics import r2_score
+    # Create ExtraTreesRegressor with custom parameters
+    model = ExtraTreesRegressor(
+        n_estimators=200,
+        criterion='squared_error',  
+        max_depth=None,
+        min_samples_split=2,
+        min_samples_leaf=1,
+        max_features=5,
+        random_state=1000
+    )
+    model.fit(X_train, y_train)
+    from sklearn.metrics import r2_score
+    y_pred = model.predict(X_test)
+    r2 = r2_score(y_test, y_pred)
+    print(f'R2 Score: {round(r2*100, 2)}')
+    y_pred = model.predict(X_train)
+    r2 = r2_score(y_train, y_pred)
+    print(f'R2 Score: {round(r2*100, 2)}')
+
+    # We can Conclude that their is low miss Prediction so model is not Overfitted
+    # import pickle as pk
+    # filename= 'crop_insurance_sum_Raghu.pkl'
+    # pk.dump(model,open(filename,'wb'))
+    def encoding(input_data):
+        input_data[0] = season_category_label_dict[input_data[0].lower().replace(" ","").replace(" ","").replace(" ","").replace(" ","")]
+        input_data[1] = scheme_category_label_dict[input_data[1].lower().replace(" ","").replace(" ","").replace(" ","").replace(" ","")]
+        input_data[2] = state_category_label_dict[input_data[2].lower().replace(" ","").replace(" ","").replace(" ","").replace(" ","")]
+        input_data[3] = district_category_label_dict[input_data[3].lower().replace(" ","").replace(" ","").replace(" ","").replace(" ","")]
+        return input_data
+    import pickle
+    pickle.dump(model,open('crop_insurance_sum_Raghu.pkl','wb'))

setup.sh

@@ -0,0 +1,13 @@
+mkdir -p ~/.streamlit/
+
+echo "\
+[general]\n\
+email = \"your-email@domain.com\"\n\
+" > ~/.streamlit/credentials.toml
+
+echo "\
+[server]\n\
+headless = true\n\
+enableCORS=false\n\
+port = $PORT\n\
+" > ~/.streamlit/config.toml

sum_insurance.py

@@ -0,0 +1,82 @@
+
+import pandas as pd
+import numpy as np
+
+
+
+data = pd.read_csv("insurance(R).csv")
+data_new = data.copy(deep = True)
+
+
+
+data.head()
+
+
+
+import re
+
+obj_columns = data.select_dtypes("object")
+
+for col in obj_columns:
+    data[col] = data[col].apply(lambda x: re.sub(r'[^a-zA-Z0-9]', '', x.lower())).astype("str")
+
+
+
+data.head()
+
+
+season_catogory = list(data.season.values)
+scheme_catogory = list(data.scheme.values)
+state_catogory  = list(data.state_name.values)
+district_catogory = list(data.district_name.values)
+
+
+
+columns = ['season','scheme','state_name','district_name']
+from sklearn.preprocessing import LabelEncoder
+encoder = LabelEncoder()
+for col in columns:
+    data[col] = encoder.fit_transform(data[col])
+
+
+
+season_label = list(data.season.values)
+scheme_label = list(data.scheme.values)
+state_label = list(data.state_name.values)
+district_label = list(data.district_name.values)
+
+
+
+season_category_label_dict = dict(zip(season_catogory, season_label))
+
+
+
+scheme_category_label_dict = dict(zip(scheme_catogory, scheme_label))
+
+
+state_category_label_dict = dict(zip(state_catogory, state_label))
+
+
+district_category_label_dict = dict(zip(district_catogory, district_label))
+
+
+from sklearn.compose import ColumnTransformer
+from sklearn.ensemble import ExtraTreesRegressor
+from sklearn.pipeline import Pipeline
+from sklearn.preprocessing import LabelEncoder, StandardScaler, FunctionTransformer
+from sklearn.model_selection import train_test_split
+
+
+X = data.drop("sum_insured", axis=1)
+y = data["sum_insured"]
+
+
+def encoding(input_data):
+      input_data[0] = season_category_label_dict[input_data[0].lower().replace(" ","").replace(" ","").replace(" ","").replace(" ","")]
+      input_data[1] = scheme_category_label_dict[input_data[1].lower().replace(" ","").replace(" ","").replace(" ","").replace(" ","")]
+      input_data[2] = state_category_label_dict[input_data[2].lower().replace(" ","").replace(" ","").replace(" ","").replace(" ","")]
+      input_data[3] = district_category_label_dict[input_data[3].lower().replace(" ","").replace(" ","").replace(" ","").replace(" ","")]
+      return input_data
+
+
+