Spaces:
Sleeping
Sleeping
| # -*- coding: utf-8 -*- | |
| """yieldpredictionrandomforest.ipynb | |
| Automatically generated by Colab. | |
| Original file is located at | |
| https://colab.research.google.com/drive/1-bKSlitmr01NPLLG_ZrTBoZ-3hCHjwM6 | |
| """ | |
| import gradio as gr | |
| from PIL import Image | |
| import pandas as pd | |
| import numpy as np | |
| import requests | |
| from sklearn.model_selection import train_test_split | |
| from sklearn.ensemble import RandomForestClassifier | |
| from sklearn.preprocessing import LabelEncoder | |
| from sklearn.metrics import confusion_matrix | |
| from sklearn.metrics import classification_report | |
| from sklearn.model_selection import train_test_split | |
| from sklearn.preprocessing import StandardScaler | |
| from sklearn.ensemble import RandomForestRegressor | |
| from sklearn.metrics import mean_squared_error, r2_score, mean_absolute_percentage_error | |
| from tensorflow.keras.models import load_model | |
| from tensorflow.keras.preprocessing import image | |
| # Load the dataset | |
| crop_data = pd.read_csv('combined_data.csv') | |
| # Convert district names to title case | |
| crop_data['District'] = crop_data['District'].str.title() | |
| # Function to fetch humidity and temperature from a weather API | |
| def get_weather_data(district): | |
| api_key = '2146dd5e46379bba1811371d760fbf18' | |
| base_url = 'http://api.openweathermap.org/data/2.5/weather?' | |
| # Build API request URL | |
| complete_url = base_url + 'q=' + district + '&appid=' + api_key | |
| # Send GET request to the API | |
| response = requests.get(complete_url) | |
| # Parse response data | |
| if response.status_code == 200: | |
| data = response.json() | |
| # Extract humidity and temperature | |
| humidity = data['main']['humidity'] | |
| temperature = data['main']['temp'] - 273.15 # Convert from Kelvin to Celsius | |
| return humidity, temperature | |
| else: | |
| print("Failed to fetch weather data. Please try again later.") | |
| return None, None | |
| # Function to calculate average rainfall for a given state | |
| def calculate_average_rainfall(state): | |
| # Define ranges for average rainfall for each state (in cm) | |
| state_rainfall_ranges = { | |
| 'Rajasthan': (5, 20), | |
| 'Manipur': (100, 300), | |
| 'Madhya Pradesh': (70, 150), | |
| 'Puducherry': (80, 200), | |
| 'Bihar': (80, 180), | |
| 'Andhra Pradesh': (80, 150), | |
| 'Chhattisgarh': (100, 200), | |
| 'Uttar Pradesh': (70, 150), | |
| 'Andaman and Nicobar Islands': (150, 300), | |
| 'Telangana': (70, 150), | |
| 'Karnataka': (70, 150), | |
| 'Gujarat': (40, 100), | |
| 'Dadra and Nagar Haveli': (100, 200), | |
| 'Meghalaya': (200, 400), | |
| 'Tamil Nadu': (70, 150), | |
| 'Maharashtra': (70, 150), | |
| 'Kerala': (200, 400), | |
| 'Assam': (200, 400), | |
| 'Goa': (200, 400), | |
| 'Mizoram': (200, 400), | |
| 'West Bengal': (200, 400), | |
| 'Jammu and Kashmir': (30, 80), | |
| 'Himachal Pradesh': (50, 120), | |
| 'Haryana': (40, 100), | |
| 'Odisha': (100, 200), | |
| 'Delhi': (30, 80), | |
| 'Nagaland': (200, 400), | |
| 'Tripura': (200, 400), | |
| 'Punjab': (30, 80), | |
| 'Uttarakhand': (100, 200), | |
| 'Arunachal Pradesh': (200, 400), | |
| 'Jharkhand': (100, 200), | |
| 'Chandigarh': (30, 80), | |
| 'Sikkim': (200, 400), | |
| 'Daman and Diu': (100, 200) | |
| } | |
| # Get the range for the given state | |
| rainfall_range = state_rainfall_ranges.get(state) | |
| if rainfall_range: | |
| # Calculate average rainfall within the range for the state | |
| average_rainfall = np.random.uniform(rainfall_range[0], rainfall_range[1]) | |
| return average_rainfall | |
| else: | |
| print(f"Average rainfall data not available for {state}.") | |
| return None | |
| def recommend_top_n_crops(state, district, soil_type, season, area, n=3): | |
| # Fetch average rainfall for the given state | |
| avg_rainfall = calculate_average_rainfall(state) | |
| if avg_rainfall is not None: | |
| # Fetch humidity and temperature for the given district | |
| humidity, temperature = get_weather_data(district) | |
| if humidity is not None and temperature is not None: | |
| # Define ranges for N, P, and K based on soil type | |
| soil_type_ranges = { | |
| 'Alluvial': {'N': (0.1, 0.9), 'P': (0.01, 0.05), 'K': (0.1, 0.8)}, | |
| 'Red': {'N': (0.1, 0.3), 'P': (0.02, 0.06), 'K': (0.2, 0.3)}, | |
| 'Loam': {'N': (0.1, 0.5), 'P': (0.01, 0.04), 'K': (0.1, 0.5)}, | |
| 'Black': {'N': (0.1, 0.3), 'P': (0.02, 0.03), 'K': (0.1, 0.3)} | |
| } | |
| # Select random values for N, P, and K based on soil type | |
| np.random.seed(42) # for reproducibility | |
| random_n_range = soil_type_ranges[soil_type]['N'] | |
| random_p_range = soil_type_ranges[soil_type]['P'] | |
| random_k_range = soil_type_ranges[soil_type]['K'] | |
| random_n = np.random.uniform(random_n_range[0], random_n_range[1]) | |
| random_p = np.random.uniform(random_p_range[0], random_p_range[1]) | |
| random_k = np.random.uniform(random_k_range[0], random_k_range[1]) | |
| # Map input strings to their encoded values | |
| state_encoded = state_encodings[state] | |
| district_encoded = district_encodings[district] | |
| soil_type_encoded = soil_type_encodings[soil_type] | |
| season_encoded = season_type_encodings[season] | |
| # Prepare input features for classification | |
| input_features_classification = np.array([[state_encoded, district_encoded, soil_type_encoded, avg_rainfall, temperature, humidity, random_n, random_p, random_k, season_encoded, 0, 0, area]]) | |
| # Make prediction using the trained classification model | |
| predicted_probs = model.predict_proba(input_features_classification)[0] | |
| # Sort predicted probabilities and get top N indices | |
| top_n_indices = np.argsort(predicted_probs)[::-1][:n] | |
| # Get top N crop recommendations | |
| top_n_crops = [crop_encodings_inverse[idx] for idx in top_n_indices] | |
| crop_yield_predictions = {} | |
| # Predict yield for the top N crops using the regression model | |
| predicted_yields = [] | |
| for crop in top_n_crops: | |
| print(crop) | |
| crop_encoded = crop_encodings[crop] | |
| # Prepare input features for regression | |
| input_features_regression = np.array([[state_encoded, district_encoded, soil_type_encoded, crop_encoded, avg_rainfall, temperature, humidity, random_n, random_p, random_k, season_encoded, 0, area]]) | |
| # Predict yield | |
| predicted_yield = regressor.predict(input_features_regression)[0] | |
| predicted_yields.append(predicted_yield) | |
| # Print top N recommended crops with their predicted yields | |
| for i in range(n): | |
| print(f'{top_n_crops[i]}: Expected Yield - {predicted_yields[i]}') | |
| return top_n_crops[0],predicted_yields[0],top_n_crops[1],predicted_yields[1],top_n_crops[2],predicted_yields[2] | |
| else: | |
| print("Failed to fetch weather data. Please try again later.") | |
| return None | |
| else: | |
| print("Failed to fetch average rainfall data. Please try again later.") | |
| return None | |
| label_encoder = LabelEncoder() | |
| crop_data['State_Encoded'] = label_encoder.fit_transform(crop_data['State']) | |
| crop_data['District_Encoded'] = label_encoder.fit_transform(crop_data['District']) | |
| crop_data['Soil_Type_Encoded'] = label_encoder.fit_transform(crop_data['Soil Type']) | |
| crop_data['Crop_Type_Encoded'] = label_encoder.fit_transform(crop_data['Crop']) | |
| crop_data['Season_Encoded'] = label_encoder.fit_transform(crop_data['Season']) | |
| # Create dictionaries to map original names to encoded labels | |
| state_encodings = dict(zip(crop_data['State'], crop_data['State_Encoded'])) | |
| district_encodings = dict(zip(crop_data['District'], crop_data['District_Encoded'])) | |
| soil_type_encodings = dict(zip(crop_data['Soil Type'], crop_data['Soil_Type_Encoded'])) | |
| season_type_encodings = dict(zip(crop_data['Season'], crop_data['Season_Encoded'])) | |
| crop_encodings = dict(zip(crop_data['Crop'], crop_data['Crop_Type_Encoded'])) | |
| crop_encodings_inverse = dict(zip(crop_data['Crop_Type_Encoded'], crop_data['Crop'])) | |
| # Split data into features and target | |
| X = crop_data[['State_Encoded', 'District_Encoded', 'Soil_Type_Encoded', 'Rainfall (cm)', 'Temperature (°C)', 'Humidity (%)', 'N', 'P', 'K', 'Season_Encoded', 'Production', 'Yield', 'Area']] | |
| y = crop_data['Crop_Type_Encoded'] | |
| # Split data into train and test sets | |
| X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42) | |
| # Train Random Forest model with fine-tuned hyperparameters | |
| model = RandomForestClassifier(max_depth=30, min_samples_split=5, n_estimators=200, random_state=42) | |
| model.fit(X_train, y_train) | |
| # Test the model | |
| test_accuracy = model.score(X_test, y_test) | |
| print("Test Accuracy:", test_accuracy) | |
| # Evaluate the model with additional measures | |
| y_pred = model.predict(X_test) | |
| conf_matrix = confusion_matrix(y_test, y_pred) | |
| print("Confusion Matrix:") | |
| print(conf_matrix) | |
| print(classification_report(y_test, y_pred)) | |
| # Split data into features and target | |
| a = crop_data[['State_Encoded', 'District_Encoded', 'Soil_Type_Encoded', 'Crop_Type_Encoded', 'Rainfall (cm)', 'Temperature (°C)', 'Humidity (%)', 'N', 'P', 'K', 'Season_Encoded', 'Production', 'Area']] | |
| b = crop_data['Yield'] # Use 'Yield' as the target for regression | |
| # Split data into train and test sets | |
| a_train, a_test, b_train, b_test = train_test_split(a, b, test_size=0.2, random_state=42) | |
| # Train Random Forest regressor with fine-tuned hyperparameters | |
| regressor = RandomForestRegressor(max_depth=30, n_estimators=300, random_state=42) | |
| regressor.fit(a_train, b_train) | |
| # Test the regressor | |
| test_score = regressor.score(a_test, b_test) | |
| print("Test Score (R-squared):", test_score) | |
| # Predict yield for the testing data | |
| b_pred = regressor.predict(a_test) | |
| # Evaluate the model | |
| mse = mean_squared_error(b_test, b_pred) | |
| print("Mean Squared Error:", mse) | |
| # Example usage: | |
| # state = 'Rajasthan' | |
| # district = 'Kota' | |
| # soil_type = 'Alluvial' | |
| # season = 'Whole Year' | |
| # Area=1 | |
| soilclassification = load_model('SoilModel.h5') | |
| def preprocess_image(image): | |
| # Convert Gradio Image object to numpy array | |
| image_array = np.array(image) | |
| # Resize the image to the required shape (256x256) | |
| resized_image = np.array(Image.fromarray(image_array).resize((256, 256))) | |
| # Normalize the image pixel values to be in the range [0, 1] | |
| normalized_image = resized_image / 255.0 | |
| # Add batch dimension to the image (model expects input shape of (None, 256, 256, 3)) | |
| input_image = normalized_image[np.newaxis, ...] | |
| return input_image | |
| def finalfunc(soil_image, state_input, district_input, season_input, area_input): | |
| preprocessed_image = preprocess_image(soil_image) | |
| prediction = soilclassification.predict(preprocessed_image) | |
| # Extracting the predicted soil type from the prediction result | |
| predicted_soil_type = prediction.argmax(axis=1)[0] | |
| finalsoiltype="" | |
| if predicted_soil_type==0: | |
| finalsoiltype="Alluvial" | |
| elif predicted_soil_type==1: | |
| finalsoiltype="Black" | |
| elif predicted_soil_type==2: | |
| finalsoiltype="Loam" | |
| elif predicted_soil_type==3: | |
| finalsoiltype= "Red" | |
| return recommend_top_n_crops(state_input, district_input, finalsoiltype, season_input, area_input, n=3) | |
| # top_3_crops = recommend_top_n_crops(state, district, soil_type, season,Area, n=3) | |
| # print('Top 3 Recommended Crops:', top_3_crops) | |
| # Input components | |
| image_input = gr.Image(label="Image of Soil") | |
| district_input = gr.Textbox(label="District") | |
| state_input = gr.Textbox(label="State") | |
| season_input = gr.Textbox(label="Season") | |
| area_input = gr.Textbox(label="Area") | |
| # # Output components | |
| crop1_name = gr.Textbox(label="Crop 1 Name") | |
| crop1_yield = gr.Textbox(label="Crop 1 Yield Percentage") | |
| crop2_name = gr.Textbox(label="Crop 2 Name") | |
| crop2_yield = gr.Textbox(label="Crop 2 Yield Percentage") | |
| crop3_name = gr.Textbox(label="Crop 3 Name") | |
| crop3_yield = gr.Textbox(label="Crop 3 Yield Percentage") | |
| # Create Gradio interface | |
| gr.Interface( | |
| fn=finalfunc, | |
| outputs=[crop1_name,crop1_yield,crop2_name,crop2_yield,crop3_name,crop3_yield], | |
| inputs=[image_input,state_input,district_input ,season_input,area_input], | |
| title="Crop Yield Prediction", | |
| description="Predict crop yields based on an image of soil, district, state, and crop information." | |
| ).launch(share=True) | |