this is the error message i got when i tried using the model. I am giving the code and…
- User
this is the error message i got when i tried using the model. I am giving the code and the error message for your reference : CODE: import pandas as pd import numpy as np import yfinance as yf import matplotlib.pyplot as plt import datetime import sys import os
from sklearn.preprocessing import LabelEncoder, StandardScaler from sklearn.model_selection import train_test_split, GridSearchCV, KFold from sklearn.metrics import ( mean_absolute_error, mean_squared_error, r2_score ) from sklearn.ensemble import RandomForestRegressor from sklearn.linear_model import LinearRegression from sklearn.svm import SVR
import xgboost as xgb
import json
For progress bar
from tqdm import tqdm
For audible alerts
import time import threading
Import TensorFlow and Keras
import tensorflow as tf from tensorflow import keras from keras.layers import Dense from keras.optimizers import Adam from keras.models import Sequential
from scikeras.wrappers import KerasRegressor
class NumpyEncoder(json.JSONEncoder): def default(self, obj): if isinstance(obj, (np.integer, np.int32, np.int64)): return int(obj) elif isinstance(obj, (np.float32, np.float64)): return float(obj) elif isinstance(obj, (np.ndarray,)): return obj.tolist() elif callable(obj): # Handle function objects return str(obj) else: return super(NumpyEncoder, self).default(obj)
def beep(): duration = 0.2 # seconds freq = 440 # Hz if sys.platform == 'win32': import winsound winsound.Beep(freq, int(duration * 1000)) else: # Beep not available on all systems, alternative is to print bell character print('\a', end='')
def play_sound_async(): threading.Thread(target=beep).start()
def transform_stock_name(name): # Remove the prefix 'NSE:' or 'BSE:' and add appropriate suffix if 'NSE:' in name: name = name.split('NSE:')[1] if '-' in name: name = name.split('-')[0] name += '.NS' elif 'BSE:' in name: name = name.split('BSE:')[1] name += '.BO' else: # Assume it's a ticker symbol and append '.NS' (adjust as needed) name += '.NS' return name
def fetch_stock_data(stock_list, start_date, end_date): stock_data = {} print("Fetching stock data...") for stock in tqdm(stock_list): try: df = yf.download(stock, start=start_date, end=end_date) if not df.empty: stock_data[stock] = df else: print(f"No data for {stock}") except Exception as e: print(f"Error downloading {stock}: {e}") return stock_data
def calculate_indicators(df): df = df.copy() # Simple Moving Averages df['SMA_5'] = df['Close'].rolling(window=5).mean() df['SMA_10'] = df['Close'].rolling(window=10).mean() df['SMA_20'] = df['Close'].rolling(window=20).mean() # Exponential Moving Averages df['EMA_5'] = df['Close'].ewm(span=5, adjust=False).mean() df['EMA_10'] = df['Close'].ewm(span=10, adjust=False).mean() # Relative Strength Index (RSI) delta = df['Close'].diff() gain = (delta.where(delta > 0, 0)).fillna(0) loss = (-delta.where(delta < 0, 0)).fillna(0) average_gain = gain.rolling(window=14).mean() average_loss = loss.rolling(window=14).mean() rs = average_gain / average_loss df['RSI'] = 100 - (100 / (1 + rs)) # Bollinger Bands df['BB_Middle'] = df['Close'].rolling(window=20).mean() df['BB_Std'] = df['Close'].rolling(window=20).std() df['BB_Upper'] = df['BB_Middle'] + (df['BB_Std'] * 2) df['BB_Lower'] = df['BB_Middle'] - (df['BB_Std'] * 2) # MACD ema_12 = df['Close'].ewm(span=12, adjust=False).mean() ema_26 = df['Close'].ewm(span=26, adjust=False).mean() df['MACD'] = ema_12 - ema_26 df['MACD_Signal'] = df['MACD'].ewm(span=9, adjust=False).mean() # Stochastic Oscillator low_min = df['Low'].rolling(window=14).min() high_max = df['High'].rolling(window=14).max() df['Stochastic'] = ((df['Close'] - low_min) / (high_max - low_min)) * 100 # Fill any remaining NaN values df.fillna(method='bfill', inplace=True) return df
def prepare_dataset(stock_data): df_list = [] for symbol, data in stock_data.items(): data = data.copy() data['Symbol'] = symbol data.reset_index(inplace=True) df_list.append(data) dataset = pd.concat(df_list, ignore_index=True) return dataset
def define_target_variable(dataset, prediction_horizon=15): dataset = dataset.sort_values(['Symbol', 'Date']) dataset['Future_Close'] = dataset.groupby('Symbol')['Close'].shift(-prediction_horizon) dataset['Future_Return'] = (dataset['Future_Close'] - dataset['Close']) / dataset['Close'] # Drop rows with NaN values in Future_Close (the last 'n' rows for each symbol) dataset = dataset.dropna(subset=['Future_Close']) return dataset
def handle_missing_values(dataset): # Fill NaNs with forward/backward fill dataset.fillna(method='ffill', inplace=True) dataset.fillna(method='bfill', inplace=True) return dataset
def encode_categorical_variables(dataset): le = LabelEncoder() dataset['Symbol_Encoded'] = le.fit_transform(dataset['Symbol']) return dataset, le
def select_features(dataset): features = dataset.drop(columns=['Date', 'Symbol', 'Future_Close', 'Future_Return']) target = dataset['Future_Return'] return features, target
def scale_features(features): scaler = StandardScaler() features_scaled = scaler.fit_transform(features) feature_names = features.columns return features_scaled, scaler, feature_names
def split_dataset(features, target): X_train, X_test, y_train, y_test = train_test_split( features, target, test_size=0.2, random_state=42 ) return X_train, X_test, y_train, y_test
def tune_random_forest_regressor(X_train, y_train): param_grid = { 'n_estimators': [100, 200], 'max_depth': [None, 5, 10], 'min_samples_split': [2, 5], } rf = RandomForestRegressor(random_state=42) grid_search = GridSearchCV( estimator=rf, param_grid=param_grid, cv=3, scoring='neg_mean_squared_error', n_jobs=-1 ) grid_search.fit(X_train, y_train) print("Best parameters for Random Forest Regressor:", grid_search.best_params_) best_rf = grid_search.best_estimator_ return best_rf
def tune_xgboost_regressor(X_train, y_train): param_grid = { 'n_estimators': [100, 200], 'max_depth': [3, 5, 7], 'learning_rate': [0.01, 0.1], } xgb_reg = xgb.XGBRegressor(eval_metric='rmse', use_label_encoder=False, random_state=42) grid_search = GridSearchCV( estimator=xgb_reg, param_grid=param_grid, cv=3, scoring='neg_mean_squared_error', n_jobs=-1 ) grid_search.fit(X_train, y_train) print("Best parameters for XGBoost Regressor:", grid_search.best_params_) best_xgb = grid_search.best_estimator_ return best_xgb
def train_neural_network_regressor(X_train, y_train): def create_nn_model(): model = Sequential() model.add(Dense(64, input_dim=X_train.shape[1], activation='relu')) model.add(Dense(32, activation='relu')) model.add(Dense(1)) # No activation for regression output optimizer = Adam(learning_rate=0.001) model.compile( loss='mean_squared_error', optimizer=optimizer, metrics=['mean_absolute_error'] ) return model
nn_model = KerasRegressor(model=create_nn_model, epochs=10, batch_size=32, verbose=0) nn_model.fit(X_train, y_train) return nn_modeldef train_linear_regression(X_train, y_train): lr_regressor = LinearRegression() lr_regressor.fit(X_train, y_train) return lr_regressor
def train_svr(X_train, y_train): svr_regressor = SVR() svr_regressor.fit(X_train, y_train) return svr_regressor
def plot_feature_importance(model, feature_names): if hasattr(model, 'feature_importances_'): importances = model.feature_importances_ indices = np.argsort(importances)[::-1]
plt.figure(figsize=(12, 6)) plt.title("Feature Importance") plt.bar(range(len(importances)), importances[indices], align='center') plt.xticks( range(len(importances)), [feature_names[i] for i in indices], rotation=90 ) plt.tight_layout() plt.show() else: print("Model does not have feature_importances_ attribute")Function to save models
def save_model(model, model_name): import joblib filename = f"{model_name}_model.pkl" joblib.dump(model, filename) print(f"{model_name} model saved to {filename}")
Function to load models
def load_model(model_name): import joblib filename = f"{model_name}_model.pkl" if os.path.exists(filename): model = joblib.load(filename) print(f"{model_name} model loaded from {filename}") return model else: print(f"No saved model found for {model_name}. Please train the model first.") return None
def save_keras_model(model, model_name): filename = f"{model_name}model.h5" model.model_.save(filename) print(f"{model_name} model saved to {filename}")
def load_keras_model(model_name): filename = f"{model_name}model.h5" if os.path.exists(filename): from keras.models import load_model keras_model = load_model(filename) print(f"{model_name} model loaded from {filename}") # Wrap the loaded Keras model back into a KerasRegressor from scikeras.wrappers import KerasRegressor
def create_nn_model(): return keras_model nn_model = KerasRegressor(model=create_nn_model) nn_model.model_ = keras_model # Set the trained model return nn_model else: print(f"No saved model found for {model_name}. Please train the model first.") return Nonedef save_scaler(scaler): import joblib joblib.dump(scaler, "scaler.pkl") print("Scaler saved to scaler.pkl")
def load_scaler(): import joblib if os.path.exists("scaler.pkl"): scaler = joblib.load("scaler.pkl") print("Scaler loaded from scaler.pkl") return scaler else: print("No saved scaler found.") return None
def save_label_encoder(le): import joblib joblib.dump(le, "label_encoder.pkl") print("Label encoder saved to label_encoder.pkl")
def load_label_encoder(): import joblib if os.path.exists("label_encoder.pkl"): le = joblib.load("label_encoder.pkl") print("Label encoder loaded from label_encoder.pkl") return le else: print("No saved label encoder found.") return None
Function to sanitize parameters for JSON serialization
def sanitize_parameters(params): sanitized_params = {} for key, value in params.items(): try: json.dumps(value) # Check if value is JSON serializable sanitized_params[key] = value except TypeError: sanitized_params[key] = str(value) return sanitized_params
def main_machine_learning(): import numpy as np import matplotlib.pyplot as plt from sklearn.model_selection import cross_val_score, KFold
# Audible beep at the start play_sound_async() print("Program started...") # Provide option to Train or Use action = input("Do you want to 'Train' the models or 'Use' existing models? Enter 'Train' or 'Use': ").strip().lower() if action not in ['train', 'use']: print("Invalid input. Exiting the program.") return if action == 'use' : # Prompt user for input stocks and prediction horizon user_stock_symbols = input("Enter the stock symbols separated by commas (e.g., AAPL, GOOGL, MSFT): ") user_stock_list = [symbol.strip() for symbol in user_stock_symbols.split(',')] elif action == 'train' : user_stock_list = [] user_stock_list = nfo_stocks.copy() # Transform stock names to Yahoo Finance format stock_list = [] #user_stock_list = [] #user_stock_list = nfo_stocks.copy() # taking all the stocks into consideration. for stock in user_stock_list: new_name = transform_stock_name(stock) stock_list.append(new_name) # Prompt user for prediction horizon prediction_horizon_input = input("Enter the prediction horizon in days (e.g., 5): ") try: prediction_horizon = int(prediction_horizon_input) except ValueError: print("Invalid prediction horizon input. Using default value of 5 days.") prediction_horizon = 5 # Prompt user for data period data_period_input = input("Enter the number of years of data to use for training (e.g., 5 or 10): ") try: data_period_years = int(data_period_input) except ValueError: print("Invalid data period input. Using default value of 5 years.") data_period_years = 5 end_date = datetime.datetime.now() start_date = end_date - datetime.timedelta(days=data_period_years*365) if action == 'train': # Fetch data stock_data = fetch_stock_data(stock_list, start_date.strftime('%Y-%m-%d'), end_date.strftime('%Y-%m-%d')) # Check if any data was fetched if not stock_data: print("No stock data fetched. Please check your stock symbols and internet connection.") return # Calculate indicators print("Calculating technical indicators...") for symbol in tqdm(stock_data): stock_data[symbol] = calculate_indicators(stock_data[symbol]) # Prepare dataset dataset = prepare_dataset(stock_data) dataset = define_target_variable(dataset, prediction_horizon=prediction_horizon) dataset = handle_missing_values(dataset) # Encode categorical variables dataset, le = encode_categorical_variables(dataset) features, target = select_features(dataset) # Save label encoder for future use save_label_encoder(le) # Add feature names for plotting feature_names = features.columns # Scale features features_scaled, scaler, feature_names = scale_features(features) # Save scaler and feature names for future use save_scaler(scaler) with open('feature_names.json', 'w') as f: json.dump(feature_names.tolist(), f) # Split dataset X_train, X_test, y_train, y_test = split_dataset(features_scaled, target) # Remove balancing step as it's not applicable for regression X_train_balanced, y_train_balanced = X_train, y_train # Train regression models print("Training regression models...") rf_model = tune_random_forest_regressor(X_train_balanced, y_train_balanced) xgb_model = tune_xgboost_regressor(X_train_balanced, y_train_balanced) nn_model = train_neural_network_regressor(X_train_balanced, y_train_balanced) lr_model = train_linear_regression(X_train_balanced, y_train_balanced) svr_model = train_svr(X_train_balanced, y_train_balanced) # Save models save_model(rf_model, "RandomForestRegressor") save_model(xgb_model, "XGBoostRegressor") save_keras_model(nn_model, "NeuralNetworkRegressor") save_model(lr_model, "LinearRegression") save_model(svr_model, "SVR") # Evaluate models models = { 'Random Forest Regressor': rf_model, 'XGBoost Regressor': xgb_model, 'Neural Network Regressor': nn_model, 'Linear Regression': lr_model, 'Support Vector Regressor': svr_model } model_performance = {} # Dictionary to store model performance for model_name, model in models.items(): print(f"\n{model_name} Evaluation:") # Predictions y_pred = model.predict(X_test) # Compute evaluation metrics mae = mean_absolute_error(y_test, y_pred) mse = mean_squared_error(y_test, y_pred) rmse = mse ** 0.5 r2 = r2_score(y_test, y_pred) print(f"Mean Absolute Error (MAE): {mae:.4f}") print(f"Mean Squared Error (MSE): {mse:.6f}") print(f"Root Mean Squared Error (RMSE): {rmse:.4f}") print(f"R-squared (R²): {r2:.4f}") # Cross-validation print(f"Performing cross-validation for {model_name}...") cv = KFold(n_splits=5, shuffle=True, random_state=42) mse_scores = -cross_val_score(model, X_train_balanced, y_train_balanced, cv=cv, scoring='neg_mean_squared_error', n_jobs=-1) mean_mse = float(mse_scores.mean()) print(f"Cross-validated MSE scores for {model_name}: {mse_scores}") print(f"Mean MSE: {mean_mse:.6f}") # Store performance metrics if hasattr(model, 'get_params'): parameters = model.get_params() parameters = sanitize_parameters(parameters) else: parameters = None model_performance[model_name] = { 'MAE': mae, 'MSE': mse, 'RMSE': rmse, 'R2': r2, 'Parameters': parameters } if model_name in ['Random Forest Regressor', 'XGBoost Regressor']: plot_feature_importance(model, feature_names) # Save model performance metrics with open('model_performance_regression.json', 'w') as f: json.dump(model_performance, f, cls=NumpyEncoder) print("Model performance metrics saved to model_performance_regression.json") # Audible beep at the end of training play_sound_async() print("Training completed.") elif action == 'use': # Load models print("Loading saved models...") rf_model = load_model("RandomForestRegressor") xgb_model = load_model("XGBoostRegressor") nn_model = load_keras_model("NeuralNetworkRegressor") lr_model = load_model("LinearRegression") svr_model = load_model("SVR") # Load scaler and label encoder scaler = load_scaler() le = load_label_encoder() # Load feature names with open('feature_names.json', 'r') as f: feature_names = json.load(f) # Load model performance metrics if os.path.exists('model_performance_regression.json'): with open('model_performance_regression.json', 'r') as f: model_performance = json.load(f) else: print("Model performance metrics not found.") model_performance = {} # Display models and their performance print("\nAvailable models:") for idx, model_name in enumerate(model_performance.keys()): performance = model_performance[model_name] print(f"{idx+1}. {model_name} - RMSE: {performance['RMSE']:.6f}") # Allow user to select a model model_choice_input = input("Enter the number corresponding to the model you want to use: ") try: model_choice = int(model_choice_input) - 1 selected_model_name = list(model_performance.keys())[model_choice] print(f"You have selected: {selected_model_name}") except (ValueError, IndexError): print("Invalid choice. Exiting the program.") return # Get the selected model models = { 'Random Forest Regressor': rf_model, 'XGBoost Regressor': xgb_model, 'Neural Network Regressor': nn_model, 'Linear Regression': lr_model, 'Support Vector Regressor': svr_model } best_model = models[selected_model_name] # Fetch recent data for prediction recent_end_date = datetime.datetime.now() recent_start_date = recent_end_date - datetime.timedelta(days=60) recent_stock_data = fetch_stock_data( stock_list, recent_start_date.strftime('%Y-%m-%d'), recent_end_date.strftime('%Y-%m-%d') ) if not recent_stock_data: print("No recent stock data fetched. Please check your stock symbols and internet connection.") return # Calculate indicators print("Calculating technical indicators on recent data...") for symbol in tqdm(recent_stock_data): recent_stock_data[symbol] = calculate_indicators(recent_stock_data[symbol]) # Prepare recent data recent_dataset = prepare_dataset(recent_stock_data) recent_dataset = handle_missing_values(recent_dataset) # Encode categorical variables recent_dataset['Symbol_Encoded'] = le.transform(recent_dataset['Symbol']) recent_features = recent_dataset.drop(columns=['Date', 'Symbol']) # Ensure recent_features has the same columns as during training # Add missing columns with default values missing_cols = set(feature_names) - set(recent_features.columns) for col in missing_cols: recent_features[col] = 0 # Remove any extra columns not in original features extra_cols = set(recent_features.columns) - set(feature_names) recent_features.drop(columns=extra_cols, inplace=True) # Reorder columns to match the original order recent_features = recent_features[feature_names] # Now transform recent_features_scaled = scaler.transform(recent_features) # Predict expected returns using the best model predictions = best_model.predict(recent_features_scaled) recent_dataset['Predicted_Return'] = predictions recent_dataset['Predicted_Future_Price'] = recent_dataset['Close'] * (1 + recent_dataset['Predicted_Return']) # Get latest date's predictions idx = recent_dataset.groupby('Symbol')['Date'].idxmax() latest_predictions = recent_dataset.loc[idx] print(f"\nPredicted returns for the next {prediction_horizon} days:") print(latest_predictions[['Symbol', 'Date', 'Close', 'Predicted_Return', 'Predicted_Future_Price']]) # Audible beep at the end of program play_sound_async() print("Program execution completed.") # Provide guidance on number of stocks and data periods print("\nGuidance on model training:") print("1. Training with more stocks generally improves model generalization but increases training time.") print("2. Using data from longer periods (e.g., 10 years) can capture more market cycles but may include outdated patterns.") print("3. Balance between the number of stocks, data period, and computational resources for optimal performance.")if name == "main": main_machine_learning()
ERROR : Program started... Do you want to 'Train' the models or 'Use' existing models? Enter 'Train' or 'Use': use Enter the stock symbols separated by commas (e.g., AAPL, GOOGL, MSFT): NSE:HAL Enter the prediction horizon in days (e.g., 5): 15 Enter the number of years of data to use for training (e.g., 5 or 10): 5 Loading saved models... RandomForestRegressor model loaded from RandomForestRegressor_model.pkl XGBoostRegressor model loaded from XGBoostRegressor_model.pkl NeuralNetworkRegressor model loaded from NeuralNetworkRegressormodel.h5 LinearRegression model loaded from LinearRegression_model.pkl SVR model loaded from SVR_model.pkl Scaler loaded from scaler.pkl Label encoder loaded from label_encoder.pkl
Available models:
- Random Forest Regressor - RMSE: 0.049318
- XGBoost Regressor - RMSE: 0.056544
- Neural Network Regressor - RMSE: 0.089290
- Linear Regression - RMSE: 0.119054
- Support Vector Regressor - RMSE: 0.083444 Enter the number corresponding to the model you want to use: 1 You have selected: Random Forest Regressor Fetching stock data... [*******************100%%********************] 1 of 1 completed | 0/1 [00:00<?, ?it/s] 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1/1 [00:02<00:00, 2.31s/it] Calculating technical indicators on recent data... 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1/1 [00:00<00:00, 83.31it/s] Traceback (most recent call last): File "C:\Users\siddh\AppData\Local\Programs\Python\Python311\Lib\site-packages\sklearn\utils_encode.py", line 225, in _encode return _map_to_integer(values, uniques) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ File "C:\Users\siddh\AppData\Local\Programs\Python\Python311\Lib\site-packages\sklearn\utils_encode.py", line 165, in _map_to_integer return np.array([table[v] for v in values]) ^^^^^^^^^^^^^^^^^^^^^^^^^^ File "C:\Users\siddh\AppData\Local\Programs\Python\Python311\Lib\site-packages\sklearn\utils_encode.py", line 165, in return np.array([table[v] for v in values]) ~~~~~^^^ File "C:\Users\siddh\AppData\Local\Programs\Python\Python311\Lib\site-packages\sklearn\utils_encode.py", line 159, in missing raise KeyError(key) KeyError: 'HAL.NS'
During handling of the above exception, another exception occurred:
Traceback (most recent call last): File "c:\Users\swarn\python_codes\python_try\hugging\predictive_26.py", line 746, in main_machine_learning() File "c:\Users\swarn\python_codes\python_try\hugging\predictive_26.py", line 702, in main_machine_learning recent_dataset['Symbol_Encoded'] = le.transform(recent_dataset['Symbol']) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ File "C:\Users\siddh\AppData\Local\Programs\Python\Python311\Lib\site-packages\sklearn\preprocessing_label.py", line 137, in transform return encode(y, uniques=self.classes) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ File "C:\Users\siddh\AppData\Local\Programs\Python\Python311\Lib\site-packages\sklearn\utils_encode.py", line 227, in _encode raise ValueError(f"y contains previously unseen labels: {str(e)}") ValueError: y contains previously unseen labels: 'HAL.NS'
- Assistant
The error you're encountering is due to the
LabelEncodernot recognizing the new stock symbol'HAL.NS'during the prediction phase. Let's delve into why this happens and how you can fix it.Understanding the Issue
During the training phase, your
LabelEncoderwas fitted on a specific set of stock symbols (tickers). It learned to map each stock symbol in the training data to a unique integer label. However, when you try to use the model to predict a stock symbol that wasn't included in the training data, theLabelEncoderdoesn't recognize it and raises aValueError.In your case, you're trying to predict for
'HAL.NS'(transformed from'NSE:HAL'), which wasn't present in your training data. Therefore, theLabelEncodercannot transform this unseen label, leading to the error:ValueError: y contains previously unseen labels: 'HAL.NS'Why This Happens
- LabelEncoder Limitation: The
LabelEncoderis designed to encode labels seen during the fitting process. It cannot handle new, unseen labels during transformation. - Model Limitations: Even if we workaround the
LabelEncoderissue, the model hasn't learned patterns from the new stock's historical data. Therefore, predicting on unseen symbols without retraining the model isn't reliable.
Solutions
-
Include the Stock in Training Data:
- Description: Add
'HAL.NS'to your training dataset and retrain the model so that theLabelEncoderrecognizes it, and the model learns from its historical data. - Steps:
- Update Training Symbols: Ensure
'HAL.NS'is included in yournfo_stocksor equivalent list used during training. - Retrain the Model: Run the training process again to incorporate the new stock.
- Use the Retrained Model: Now, the model can predict for
'HAL.NS'.
- Update Training Symbols: Ensure
- Description: Add
-
Modify the Encoding Approach:
- Description: Use an encoding method that can handle unseen labels, such as
OneHotEncoderwith thehandle_unknown='ignore'parameter or consider removing theSymbolfeature altogether if appropriate. - Caution: This method won't make the model learn from unseen stock data; it only prevents the encoding error. Predictions may still be unreliable.
- Description: Use an encoding method that can handle unseen labels, such as
-
Use Only Known Symbols:
- Description: Predict only for stock symbols included in the training data.
Recommended Solution
Retrain the Model Including
'HAL.NS'This is the most reliable solution as it allows the model to learn from the historical data of
'HAL.NS', leading to more accurate predictions.Here's how you can do it:
-
Update Your Training Stock List:
- Ensure
'HAL.NS'is included in the list of stock symbols used for training. - If you're using
nfo_stocks, add'HAL.NS'to this list.
user_stock_list = nfo_stocks.copy() user_stock_list.append('HAL.NS') # Add HAL.NS to the training data - Ensure
-
Retrain the Model:
- Run the training part of your code (
action == 'train'). - This will fetch data for all stocks, including
'HAL.NS', calculate technical indicators, and retrain the models.
- Run the training part of your code (
-
Use the Model for Predictions:
- Now, when you switch to
'Use'mode, theLabelEncoderwill recognize'HAL.NS'. - The model can make predictions for
'HAL.NS'.
- Now, when you switch to
Code Modifications
Here's how you can adjust your code:
Include
'HAL.NS'in TrainingEnsure
'HAL.NS'is in your training dataset.if action == 'train': # Existing code to initialize user_stock_list user_stock_list = nfo_stocks.copy() # Add HAL.NS if not already in the list if 'HAL.NS' not in user_stock_list: user_stock_list.append('HAL.NS')Handle Missing Variables
Make sure
nfo_stocksis defined in your code. If it's not, you need to define it or replace it with your list of training stock symbols.# Define nfo_stocks somewhere at the beginning of your code nfo_stocks = ['RELIANCE.NS', 'TCS.NS', 'INFY.NS', ...] # Add your stocks hereRe-Train the Model
After updating the training stock list, re-run your training process:
if action == 'train': # Your existing training code... # This will now include HAL.NS in the training dataVerify the Solution
After retraining, you should be able to use the model to predict for
'HAL.NS'without encountering theValueError.Alternative Encoding Methods
If retraining isn't feasible, you can consider modifying the encoding approach:
Use OneHotEncoder with
handle_unknown='ignore'Replace the
LabelEncoderwithOneHotEncoder. This encoder can be configured to ignore unseen labels.from sklearn.preprocessing import OneHotEncoder def encode_categorical_variables(dataset): ohe = OneHotEncoder(handle_unknown='ignore', sparse=False) symbol_encoded = ohe.fit_transform(dataset[['Symbol']]) symbol_encoded_df = pd.DataFrame(symbol_encoded, columns=ohe.get_feature_names_out(['Symbol'])) dataset = pd.concat([dataset.reset_index(drop=True), symbol_encoded_df], axis=1) return dataset, oheAdjust the loading and saving functions accordingly.
Note: Using
OneHotEncodercan significantly increase the number of features, especially with many stock symbols, and may affect model performance.Final Thoughts
While it's technically possible to adjust the
LabelEncoderto handle unseen labels, this doesn't address the underlying issue that the model hasn't learned from the new stock's historical data. For accurate predictions, it's essential that the model is trained on the stock data you're interested in.Adjusting Your Model to Not Use the Symbol Feature
Another approach is to remove the
Symbolfeature entirely from your training and prediction process. This way, the model focuses solely on the technical indicators and price data, which might generalize better to new stocks.Modify Feature Selection
def select_features(dataset): # Exclude 'Symbol_Encoded' from features features = dataset.drop(columns=['Date', 'Symbol', 'Symbol_Encoded', 'Future_Close', 'Future_Return']) target = dataset['Future_Return'] return features, targetAdjust the Rest of the Code
- Remove any encoding of the
Symbolfeature. - Ensure that during prediction, the model doesn't expect the
Symbol_Encodedfeature.
Caution: Excluding the
Symbolfeature may reduce model performance if different stocks have distinct behaviors, but it increases the model's ability to generalize to unseen stocks.Summary
- Best Practice: Retrain your model including all stocks you want to predict.
- Alternative: Adjust the encoding method or remove the
Symbolfeature. - Recommendation: For accurate predictions, it's essential to have the stock's historical data included during training.
Let me know if you need further assistance or clarification on any of these steps!
- LabelEncoder Limitation: The