We are looking for an experienced Deep Learning Engineer/Python Developer to build a predictive model for the Indian Stock Market (Nifty Index Options). We possess high-granularity historical data (1-second level) and require a model that can calculate the probability of trade success based on a specific custom logic involving price action and time decay. The goal is not just price prediction, but classification of trade setups (Success vs. Failure probability) for Option Selling strategies. The DataWe have granular CSV files named by date (e.g., 2025-02-11.csv). The data granularity is 1-second intervals.Structure:Index Data: Timestamp, Nifty OHLC, India VIX OHLC.Options Data: A wide dataset containing OHLC, Volume, and OI for multiple Strike Prices (Call and Put) for every second.Format: TIMESTAMP, NIFTY_OHLC..., 22650_CALL_OPEN, ..., 22650_PUT_OPEN... etc. The TaskYou will be responsible for:Data Preprocessing: Cleaning and structuring the 1-second interval data.Feature Engineering: Creating rolling windows, calculating technical indicators, or utilizing raw time-series data. Target Labeling (Crucial): Implementing a specific logic (defined below) to label historical rows as "Success" (1) or "Failure" (0). Model Architecture: Designing a Deep Learning model (LSTM, GRU, Transformer, or TCN) to predict the probability of "Success" at any given second.The Trading Logic (Target Definition)The model must dynamically identify the active strike and calculate the outcome based on the following logic:Identify Strike: For each row (timestamp), determine the Nearest OTM (Out of The Money) Strike.Example: If Nifty Close is 23,475 - Nearest OTM Call is 23,500 | Nearest OTM Put is 23,450.Define Entry ($x$): The LOW price of that specific Option Strike for that specific second.Define Exits:Target: $x - 4$ points (Shorting the option).Stop Loss: $x + 28$ points.Determine Label: Look ahead in the future data:Success (1): The Option High touches $x - 4$ BEFORE the Option High touches $x + 28$.Failure (0): The Option High touches $x + 28$ first, OR it never touches the target within the trading day. Time Weighting: The model should favor setups where the Target is hit faster. (e.g., a trade that hits the target in 1 minute is "better" than one that takes 3 hours, though both are successes).RequirementsPython Proficiency: Expert level (Pandas, NumPy, Numba for fast data iteration).Deep Learning Frameworks: PyTorch or TensorFlow/Keras.Financial Knowledge: Understanding of Options (Calls/Puts, OTM, Strike Prices) is mandatory. You must understand that we are selling/shorting options (profiting from price drop).Handling Big Data: The dataset is large (1-second tick data). You must know how to handle memory efficient data loading.DeliverablesPython Script: Fully commented code for Data Preprocessing (Label generation) and Model Training. Trained Model: The saved model weights (.h5 or .pt).Inference Script: A script that takes a new row of data and outputs a Probability Score (0.00 to 1.00) for the current Nearest OTM Call and Put.Performance Report: Backtesting results showing Accuracy, Precision, Recall, and ROC-AUC curve on a validation set.Screening Questions (Please answer these in your proposal)Have you worked with high-frequency (tick or 1-second) financial data before?Based on the logic provided ($x-4$ vs $x+28$), this is a high-risk/reward ratio strategy. How would you handle class imbalance if "Failures" happen much less frequently than "Successes" (or vice versa)?Which Deep Learning architecture would you suggest for this specific time-series probability problem (LSTM, Transformer, etc.) and why?Tips for you (The User) regarding this post:The Logic Clarification: In the job post, I clarified that this is a Short Selling strategy. Since you said "Success is x-4", that implies you want the price to drop. I added the term "Shorting" so developers don't get confused thinking it's a buying strategy where price drops are bad.Exit Logic: I refined your logic slightly for the developer: "...for x it should check assume the value in low column... and for exiting the trade it should check high of the ohlc" - I mapped this to the standard trading logic in the post to ensure they backtest correctly against the "worst case" price in the candle (High) for the Stop Loss.Time Sensitivity: I added the "Time Weighting" requirement. A standard binary classification model treats a win in 1 second the same as a win in 5 hours. If you want the model to prefer fast wins, the developer needs to build a custom Loss Function or Sample Weighting strategy. I included this in the requirements.