点击下载代码
Nanodegree key: nd881
Version: 2.0.33
Locale: en-us
Start mastering AI-powered trading with this Nanodegree. Learn to build, backtest, and optimize sophisticated AI-driven trading models, gaining practical skills to succeed in dynamic financial markets.
Content
Part 01 : Welcome to the Nanodegree Program!
Welcome to Udacity! We're excited to share more about your Nanodegree program and start this journey with you!
-
Module 01: Welcome to the Nanodegree Program!
-
Lesson 01: Welcome!
Welcome to Udacity. Takes 5 minutes to get familiar with Udacity courses and gain some tips to succeed in courses.
-
Lesson 02: Getting Help
You are starting a challenging but rewarding journey! Take 5 minutes to read how to get help with projects and content.
-
Part 02 : Building a Workflow for AI
Refine your skills in AI-based trading by mastering key machine learning techniques such as reinforcement learning, supervised and unsupervised learning. Develop and backtest trading models using real financial data.
-
Module 01: Building a Workflow for AI
-
Lesson 01: Introduction to AI Workflows in Trading
Learn how to prepare price data for AI models, backtest trading algorithms, and build a simple RSI algorithm.
- Concept 01: Introduction
- Concept 02: Obtaining Historical Price Data
- Concept 03: Demo: Creating Historical Returns
- Concept 04: Creating Historical Returns
- Concept 05: Demo: Forward and Feature Returns
- Concept 06: Exercise: Creating Data and Backtesting a Strategy
- Concept 07: Exercise Solution: Creating Data and Backtesting a Strategy
- Concept 08: Computing Performance
- Concept 09: Demo: Computing Performance
- Concept 10: Creating Indicators
- Concept 11: Demo: Creating Indicators
- Concept 12: Building a Strategy
- Concept 13: Demo: Building a Strategy
- Concept 14: Evaluation Metrics
-
Lesson 02: Unsupervised Learning
Explore investment data, summarize key stats, use K-Means and PCA for clustering, adapt trading algorithms, and identify risk factors to enhance model insights on outperformance
- Concept 01: Introduction to Unsupervised Learning
- Concept 02: A Brief Overview of Unsupervised Learning Methods
- Concept 03: Theory and Concepts: K-means
- Concept 04: K-means Demo
- Concept 05: Theory and Concepts: PCA
- Concept 06: PCA Demo
- Concept 07: Practical Application: K-means
- Concept 08: K-means Application Demo
- Concept 09: Exercise K-Means
- Concept 10: Exercise K-Means Solution
- Concept 11: Practical Application: PCA
- Concept 12: PCA Application Demo
- Concept 13: Exercise PCA
- Concept 14: Exercise PCA Solution
- Concept 15: Conclusion
-
Lesson 03: Supervised Learning: Regression
Build regression models using past returns, explore regularization to avoid over/underfitting, and differentiate between training and test data while identifying signs of overfitting and underfitting.
- Concept 01: Brief Overview of Supervised Learning
- Concept 02: Multiple Linear Regression
- Concept 03: Regularization Techniques
- Concept 04: Data Preparation Demo
- Concept 05: Regression Analysis
- Concept 06: Regression Model Demo
- Concept 07: Exercise Regression
- Concept 08: Exercise Regression Solution
- Concept 09: Lasso Regression Demo
- Concept 10: Ridge Regression Demo
- Concept 11: Elastic Net Regression Demo
- Concept 12: Exercise Elastic Net
- Concept 13: Exercise Elastic Net Solution
- Concept 14: Conclusion
-
Lesson 04: Supervised Learning: Classification
Predict categorical variables using logistic regression and decision trees. Improve model performance with cross-validation for strong out-of-sample results.
- Concept 01: Overview of Supervised Learning- Classification
- Concept 02: Introduction to Logistic Regression
- Concept 03: Demo Logistic Regression
- Concept 04: Exercise Log Reg
- Concept 05: Exercise Log Reg Solution
- Concept 06: Practical Application of Logistic Regression
- Concept 07: Binary Classification Demo
- Concept 08: Decision Trees
- Concept 09: Decision Trees Demo
- Concept 10: Exercise Decision Tree
- Concept 11: Exercise Decision Tree Solution
- Concept 12: Cross Validation
- Concept 13: Cross Validation Demo
- Concept 14: Conclusion
-
Lesson 05: Reinforcement Learning
Explore reinforcement learning (RL) and its components, Q-learning, the DQN algorithm, and how to build and backtest an RL model.
- Concept 01: Introduction to Reinforcement Learning
- Concept 02: Introduction to Q Learning
- Concept 03: Evaluation Metrics
- Concept 04: Demo Part 1: Applying an RL Model to the Cartpole Environment
- Concept 05: Demo Part 2: Applying an RL Model to a Custom Environment
- Concept 06: Demo Part 3: Reinforcement Model Versatility
- Concept 07: Demo Part 4: Applying an RL Model to a Small Stock Market Dataset
- Concept 08: Demo Part 5: Applying a RL Model to a Historic Market Dataset
- Concept 09: Exercise Reinforcement Learning
- Concept 10: Exercise Reinforcement Learning Solution
- Concept 11: Deciding What System to Use
- Concept 12: Conclusion
-
Part 03 : Preparing for Data Analysis
Refine your approach to data preparation. Dive into reprocessing techniques, feature engineering strategies, and exploratory analysis with Pandas, matplotlib, and Plotly to uncover insights and enhance machine learning outcomes.
-
Module 01: Preparing for Data Analysis
-
Lesson 01: An Overview of Machine Learning Pipelines
We'll define the steps of the machine learning pipeline, from data ingestion to production. We'll emphasize preprocessing and feature engineering, essential steps to well-performing trading models.
- Concept 01: Introduction to Machine Learning Pipeline
- Concept 02: Data Collection
- Concept 03: Data Pre-Processing
- Concept 04: Feature Engineering: Transforming Raw Data into Predictive Variables
- Concept 05: Model Selection: Choosing the Right Algorithm
- Concept 06: Hyperparameter Tuning: Optimizing Model Performance
- Concept 07: Model Deployment and Monitoring: Putting ML into Production
- Concept 08: The Machine Learning Pipeline is Iterative
- Concept 09: When to Stop Refining Your Model
- Concept 10: Conclusion
-
Lesson 02: Data Acquisition and Preprocessing
How do you get data from the Internet to your model? We'll talk about ingestion, transformation,and data wrangling using Pandas, the industry-standard time-series package for data manipulation.
- Concept 01: Introduction to Data Ingestion
- Concept 02: Data Source Analysis and APIs
- Concept 03: Data Preprocessing Steps
- Concept 04: Data Cleaning and Transformation
- Concept 05: Data Interpolation and Reshaping
- Concept 06: Demo: Fixing Errors in Numeric Data Using Pandas
- Concept 07: Exercise: Fixing Data in Pandas DataFrame
- Concept 08: Exercise Solution
- Concept 09: Batch Processing for Training and Backtesting
- Concept 10: Stream Processing Inference Data
- Concept 11: Demo: Coinbase API Demo
- Concept 12: Exercise: Pull Data from YFinance API
- Concept 13: Exercise Solution
- Concept 14: Conclusion
-
Lesson 03: Feature Engineering for Trading Models
Feature engineering significantly improves model performance, and in this lesson, we'll go over strategies you can use. Basic and more involved techniques will be presented, with use cases noted.
- Concept 01: Introduction to Feature Engineering in Trading Models
- Concept 02: Feature Engineering Techniques
- Concept 03: Categorical Variables
- Concept 04: Pitfalls When Engineering Time Series Features
- Concept 05: Demo: Feature Engineering for Trading Models
- Concept 06: Exercise: Feature Engineering for Trading Models
- Concept 07: Exercise Solution
- Concept 08: Feature Selection Methods for Trading Models
- Concept 09: Preprocessing for Text Data and NLP
- Concept 10: Demo: Using Time Series Data for Trading Models
- Concept 11: Putting It All Together: Case Studies in Feature Engineering for Trading Models
- Concept 12: Exercise: Time Series Manipulations in Pandas
- Concept 13: Exercise Solution
- Concept 14: Conclusion
-
Lesson 04: Exploratory Data Analysis
What's your data trying to tell you? Use EDA, exploratory data analysis, to find out! We'll use Python's two most popular plotting packages, matplotlib and Plotly, to find out your data's secrets.
- Concept 01: Introduction to Exploratory Data Analysis
- Concept 02: Descriptive Statistics
- Concept 03: Data Visualization using Matplotlib
- Concept 04: Demo: Matplotlib
- Concept 05: Exercise: Using MatPlotLib to plot
- Concept 06: Exercise Solution
- Concept 07: Data Visualization using Plotly
- Concept 08: Demo: Plotly
- Concept 09: Exercise: Using Plotly to plot
- Concept 10: Exercise Solution
- Concept 11: Outliers and Anomaly Detection
- Concept 12: Correlation & Covariance in Trading Data
- Concept 13: Case Studies and Applications
- Concept 14: Conclusion
-
Lesson 05: Project: Data Transformation for Trading Models
Learners will use historical stock prices for two large companies to practice data manipulation and exploratory data analysis, or EDA.
Project Description - Data Transformation for Trading Models
-
Part 04 : Evaluating Returns and Backtesting
This course will advance learners' abilities to construct and backtest strategies. The curriculum emphasizes a deep understanding of key performance metrics—such as annualized returns, volatility, and various risk-adjusted ratios—to critically evaluate the effectiveness of trading strategies. Additionally, learners will enhance their skills in visualizing strategy performance through advanced graphical representations. By mastering the implementation and rigorous evaluation of trading models, students will be well-equipped to optimize strategies and ensure robust performance in the world of capital markets.
-
Module 01: Evaluating Returns and Backtesting
-
Lesson 01: Measuring Returns
Understand the foundations for backtesting. Learners will examine formulas and develop tools for calculating and plotting returns.
- Concept 01: An Introduction to Measuring Returns
- Concept 02: Introducing Arithmetic Returns
- Concept 03: Cumulative Returns
- Concept 04: Exercise: Calculating Cumulative Returns
- Concept 05: Exercise Solution
- Concept 06: Compounded Average Growth Rate
- Concept 07: Exercise: Annualizing the Mean Return
- Concept 08: Exercise Solution
- Concept 09: Cumulative Compounded Returns Demo
- Concept 10: Exercise: Calculating and Plotting Key Returns
- Concept 11: Exercise Solution
- Concept 12: Key Takeaways
-
Lesson 02: Measuring Risks
Understand volatility, skewness, kurtosis, and the impacts that these concepts have on developing a trading strategy.
- Concept 01: Calculating Volatility
- Concept 02: Annualizing Volatility
- Concept 03: Exercise: Annualized Volatility
- Concept 04: Exercise Solution
- Concept 05: Limitations of the Annualized Volatility
- Concept 06: Skewness in Finance
- Concept 07: Skewness in Finance Demo
- Concept 08: Kurtosis in Finance
- Concept 09: Kurtosis in Finance Demo
- Concept 10: Understanding and Calculating Drawdown
- Concept 11: Calculating and Visualizing Drawdown Demo
- Concept 12: Exercise: Calculating Drawdown
- Concept 13: Exercise Solution
- Concept 14: Practical Approach to Risk Measures in Trading
-
Lesson 03: Measuring Risk-Adjusted Returns
Explore drawdowns, how to calculate them, and which ratios should be employed when developing a backtest strategy. Calculations include the Sharpe, Sortino, and Calmar Ratio.
- Concept 01: An Introduction to Risk Adjusted Concerns
- Concept 02: Understanding the Risk-Free Rate
- Concept 03: Limitations of the Sharpe Ratio
- Concept 04: Sharpe Ratio Demo
- Concept 05: Calculating Sharpe Ratio Demo
- Concept 06: Sortino Ratio
- Concept 07: Calmar Ratio
- Concept 08: Comprehensive Metrics for a Diversified Portfolio Demo
- Concept 09: Exercise: Calculating Sharpe, Sortino, and Calmar Ratio
- Concept 10: Exercise Solution
-
Lesson 04: Backtesting a Risk Parity Portfolio
Through Python, learn how to implement Walk-Forward Validation and combine core calculations to develop a robust backtesting strategy.
- Concept 01: Introduction to Walk-Forward Validation
- Concept 02: Implementing Rolling Windows with Pandas
- Concept 03: Preparing and Preprocessing Financial Datasets Demo
- Concept 04: Calculating Risk Parity Asset Weights Demo
- Concept 05: Exercise: Compute Risk Parity Weights
- Concept 06: Exercise Solution
- Concept 07: Evaluating Performance on Unseen Data Demo
- Concept 08: Exercise: Core Calculations
- Concept 09: Exercise Solution
-
Lesson 05: Project: Evaluating and Backtesting a Dynamic Investment Strategy
Assess and manage investment risk through key calculations such as Volatility, Sharpe Ratio, Sortino Ratio, Calmar Ratio. Learners develop and backtesting a strategy using Walk-Forward Validation.
Project Description - Evaluating and Backtesting a Dynamic Investment Strategy
Project Rubric - Evaluating and Backtesting a Dynamic Investment Strategy
-
Part 05 : Reinforcement Learning
In this course, learners will explore how to design, backtest, and optimize a working reinforcement-based ML trading strategy. This course will introduce popular techniques and indicators used in reinforcement learning-based trading, such as Q-learning, PCA, use of market indicators, assessment of market context, and assessment of the strategy outcomes. This course is designed for hobby traders with a background in data science. By the end of this course, you will be able to build, train, backtest, and optimize a reinforcement learning trading strategy with Python.
-
Module 01: Reinforcement Learning
-
Lesson 01: Reinforcement Learning in Trading
Introduction to reinforcement learning, Q-learning, and core concepts including how reinforcement learning fits in the trading world.
- Concept 01: Introduction to Reinforcement Learning
- Concept 02: Exercise 1: Animal Habitat
- Concept 03: Exercise 1: Solution
- Concept 04: Components of Reinforcement Learning in Trading
- Concept 05: Exercise 2: RL Componenets in Finance
- Concept 06: Exercise 2: Solution
- Concept 07: Applying Reinforcement Learning in Trading
- Concept 08: Exercise 3: Stochastic vs. Deterministic Policy
- Concept 09: Exercise 3: Solution
- Concept 10: Understanding Q-learning: History and Application in Financial Markets
- Concept 11: Benefits and Challenges of Using Reinforcement Learning in Trading
- Concept 12: Exercise 4: Manual Training Steps
- Concept 13: Exercise 4: Solution
- Concept 14: Case Studies: Real-world Applications of Reinforcement Learning in Trading
- Concept 15: Process Overview: Introducing Reinforcement Learning
- Concept 16: Quiz
-
Lesson 02: Representing the Financal Market: State and Action Spaces
Explore the concept of Financial State and Action Spaces. Learn how to define states and extract popular market indicators and conditions with Python and YFinance.
- Concept 01: Introduction to Market Features in Financial Data
- Concept 02: Demo: Data Cleaning
- Concept 03: Demo: Feature Definition
- Concept 04: Exercise 1: Features & Technical Indicators in Python
- Concept 05: Exercise 1: Solution
- Concept 06: Understanding State Spaces for RL in Financial Markets
- Concept 07: Constructing Financial State Spaces Part 1
- Concept 08: Constructing Financial State Spaces Part 2
- Concept 09: Exercise 2: Calculating a State Space
- Concept 10: Exercise 2: Solution
- Concept 11: Normalizing Financial State Spaces
- Concept 12: Demo: Normalization
- Concept 13: Exercise 3: Normalizing a State Space in Python
- Concept 14: Exercise 3: Solution
- Concept 15: The Action Space
- Concept 16: Quiz
-
Lesson 03: Constructing a Reinforcement Trading Model
Construct a RL trading model using Python including define and running a training loop. Learn key tips for implementation and run test data through the newly created model.
- Concept 01: Internal Components of a Reinforcement Trading Model: DQN and Rewards
- Concept 02: Exercise 1: Calculating Log Returns
- Concept 03: Exercise 1: Solution
- Concept 04: Internal Components of an RL Trading Agent - Policy
- Concept 05: Demo: Defining DQN Architecture
- Concept 06: Demo: Defining Act Function and Experience Replay
- Concept 07: Exercise 2: Defining a Trading Agent in Python
- Concept 08: Exercise 2: Solution
- Concept 09: Understanding the Training Process
- Concept 10: Training a Profitable Agent
- Concept 11: Demo: Preparing for Training in Python
- Concept 12: Demo: Training a DQN Model in Python
- Concept 13: Exercise 3: Training your DQN in Python
- Concept 14: Exercise 3: Solution
- Concept 15: Conclusion
- Concept 16: Quiz
-
Lesson 04: Backtesting and Optimization Techniques
Examine key backtesting concepts, gather important backtesting information on an RL model, and learn how to interpret those results to optimize performance.
- Concept 01: Backtesting & Optimization Refresher
- Concept 02: Demo: Backtesting Preparation in Python
- Concept 03: Demo: Backtest 2
- Concept 04: Evaluating Backtest Results
- Concept 05: Techniques for Optimizing Trading Strategies
- Concept 06: Backtesting Pitfalls to Avoid
- Concept 07: Quiz
- Concept 08: Course Wrap-Up
-
Lesson 05: Project: Building a Reinforcement Learning Trading Model
The Project for this course will involve the students building and training RL Q-learning agent from scratch in a jupyter notebook.
Project Description - Building a Reinforcement Learning Trading Model
Project Rubric - Building a Reinforcement Learning Trading Model
-
Part 06 : Optimizing AI Strategies
This course covers various aspects of improving AI models. Topics include introduction to model optimization, hyperparameter tuning, regularization techniques, evaluating and optimizing strategies, and deployment considerations. Students will learn how to monitor, evaluate and enhance model performance, prevent overfitting, and apply techniques for real-world scenarios.
-
Module 01: Optimizing AI Strategies
-
Lesson 01: Introduction to AI Model Optimization
We review how AI models work in principle and important terminology used in AI model training and optimization. We talk about where AI model optimization applies in using AI models for trading.
- Concept 01: Introduction
- Concept 02: Exercise: Load, Inspect and Clean Data
- Concept 03: Exercise Solution
- Concept 04: A High Level Review
- Concept 05: Peeking Under the Hood
- Concept 06: AI Models as Optimizers
- Concept 07: Models Optimization: Optimizing the Optimizer
- Concept 08: Model Inputs: Features vs Samples
- Concept 09: Data Preparation
- Concept 10: Feature Engineering and Feature Scaling
- Concept 11: Feature Selection
- Concept 12: Train-Test-Split, Data Leakage, and Other Considerations
- Concept 13: Demo 1: Data Cleaning and Preprocessing
- Concept 14: Demo 2: Feature Engineering and Scaling
-
Lesson 02: Regularization Techniques to Prevent Overfitting
Overfitting is a common issue when training AI models for trading. We’ll explore bias, variance, and the role of hyperparameters in the context of various AI model types.
- Concept 01: Machine Learning Models
- Concept 02: The Bias-Variance Trade-off
- Concept 03: Cross-Validation
- Concept 04: Exercise 1: Cross-Validation and the Train-Test Split
- Concept 05: Exercise 1 Solution
- Concept 06: Model Performance and Loss
- Concept 07: Identifying and Mitigating Overfitting and Underfitting
- Concept 08: Dimensionality Reduction
- Concept 09: Addressing Overfitting with Regularization
- Concept 10: Regularization in Distance-Based Models
- Concept 11: Regularization in Tree-Based Models
- Concept 12: Exercise 2: Regularizing a Decision Tree Model
- Concept 13: Exercise 2 Solution
- Concept 14: Ensemble Methods
- Concept 15: Demo 1: Cross-Validation and the Train-Test Split
- Concept 16: Demo 2: Dimensionality Reduction with Principal Components Analysis (PCA)
- Concept 17: Demo 3: Optimizing k-Nearest Neighbors (k-NN) Algorithms
- Concept 18: Demo 4: Optimizing Decision Tree Models
-
Lesson 03: Hyperparameter Tuning Methods
Get hands-on with AI model hyperparameters and discuss the various methods available to us for tuning them in a systematic or ad-hoc way, as well as the advantages and disadvantages of each method.
- Concept 01: Parameters and Hyperparameters
- Concept 02: Hyperparameter Tuning: Manual Search
- Concept 03: Grid Search
- Concept 04: Demo 1: Hyperparameter Tuning with Grid Search
- Concept 05: Demo 2: Hyperparameter Tuning with Random Search
- Concept 06: Exercise 1: Hyperparameter Tuning with Grid Search
- Concept 07: Exercise 1 Solution
- Concept 08: Case Study: Introduction
- Concept 09: Case Study: Tuning
- Concept 10: Advanced Topics
-
Lesson 04: Evaluating and Optimizing AI Strategies
We discuss some practical methods and important considerations related to model optimization and evaluation in the context of AI models for trading.
- Concept 01: Introduction to Evaluation
- Concept 02: Performance Metrics for AI Trading Models
- Concept 03: Time-Based Cross-Validation
- Concept 04: Demo 1: Time-Based Cross-Validation
- Concept 05: Model Interpretability and Feature Analysis
- Concept 06: Backtesting and Forward Testing
- Concept 07: Model Drift and Drift Detection Techniques
- Concept 08: Mitigation Strategies for Model Drift
- Concept 09: Demo 2: Feature Selection, Feature Importance and Model Interpretation
- Concept 10: Exercise 1: Feature Selection, Feature Importance and Interpretation
- Concept 11: Exercise 1 Solution
-
Lesson 05: Deployment and Real-World Considerations
We analyze important practical considerations for using AI models for trading. We discuss things we need to keep in mind as we maintain or iterate on our deployed models.
- Concept 01: Deployment Fundamentals
- Concept 02: Monitoring and Maintaining Live Trading Systems
- Concept 03: Real World Data Challenges
- Concept 04: Strategy Implementation in Practice
- Concept 05: Optimizing Order Execution
- Concept 06: Portfolio and Risk Management Considerations
- Concept 07: Optimizing AI Trading Strategies Summary
-
Lesson 06: Project: Building and Optimizing a Classification Model for Trading
Optimize a stock price prediction model using data preprocessing, hyperparameter tuning, over/underfitting detection, model evaluation, and feature selection.
Project Description - Building and Optimizing a Classification Model for Trading
Project Rubric - Building and Optimizing a Classification Model for Trading
-
Part 07 : Momentum-Based Trading
In this course, learners will explore how to design, backtest, and optimize a working momentum-based ML trading strategy.
-
Module 01: Momentum-Based Trading
-
Lesson 01: What is Momentum-Based Trading
Normal distribution and geometric Brownian motion are key to momentum trading. Shapiro-Wilk’s and Student’s t-tests are useful statistical tools for developing momentum-based trading strategies.
- Concept 01: Introduction to Momentum Trading
- Concept 02: Identify the momentum
- Concept 03: Introduction to the normal distribution
- Concept 04: Examples of calculating the mean and the standard deviation
- Concept 05: PDF of the normal distribution
- Concept 06: CDF of the normal distribution & the standard normal distribution
- Concept 07: Expectation & Conditional expectation of the normal distribution
- Concept 08: Introduction to Brownian motion
- Concept 09: Brownian motion calculations - probabilities by calculus
- Concept 10: Understand the Shapiro-Wilk's test
- Concept 11: Understand the Student's t-test
- Concept 12: Exercise: The Normal distribution & the t-test
- Concept 13: Exercise Solution
- Concept 14: Summary of Lesson 1
-
Lesson 02: Identifying and Extracting Momentum Features
Explore geometric Brownian motion for stock price modeling, calibration, forecasting, and confidence intervals, followed by deriving and coding the Black-Scholes formula for European option pricing.
- Concept 01: Brownian motion with drift and introduction to SDE
- Concept 02: Introduction to Geometric Brownian motion
- Concept 03: Similarity of GBM to an Exponential Function
- Concept 04: Confidence interval of the GBM price forecast
- Concept 05: Calibrating GBM to data
- Concept 06: Introduction to European options and fairness of prices
- Concept 07: Time value of money
- Concept 08: Risk-neutral probability measure
- Concept 09: Black-Schole's formula
- Concept 10: Exercise: The Geometric Brownian Motion - Calibration & the Monte Carlo Simulation
- Concept 11: Exercise Solution
- Concept 12: Lesson Summary
-
Lesson 03: Constructing a Momentum Trading Model
Building a momentum-based trading program using MySQL/SQLite, Python, and geometric Brownian motion for price forecasting, confidence intervals, and Monte-Carlo simulation for scenario analysis.
- Concept 01: Introduction to Databases and SQL
- Concept 02: Create tables for historical stock prices
- Concept 03: Loading Data into MySQL
- Concept 04: Building a Trading Program Using Python
- Concept 05: Set up a bookkeeping database
- Concept 06: Program the trading strategy
- Concept 07: Forecast Future stock Prices
- Concept 08: Demo: Forecast Stock Prices Using GBM
- Concept 09: Simulate stock price trajectories
- Concept 10: Price Analysis Using the GBM Model
- Concept 11: Exercise: Forecasting future stock prices & building a trading program
- Concept 12: Exercise Solution
- Concept 13: Lesson Summary
-
Lesson 04: Backtesting and Optimization Techniques
The lesson covers back-testing momentum strategies, evaluating with Sharpe ratio and maximum drawdown, and quantitative risk management using Value-at-Risk (VaR) and Expected Shortfall (ES) in Python.
- Concept 01: Introduction to Backtesting
- Concept 02: Implementing Backtesting
- Concept 03: Calculating the Sharpe ratio
- Concept 04: Calculating the Maximum Drawdown
- Concept 05: Scenario Analysis
- Concept 06: Introduction to quantitative risk management
- Concept 07: Calculation of the Expected Shortfall
- Concept 08: Demo: Backtesting
- Concept 09: Exercise: Building a trading program and backtesting
- Concept 10: Exercise Solution
- Concept 11: Summary
-
Lesson 05: Project: Build a Momentum-Based Algorithmic Trading Program
Build a momentum-based strategy to trade the S&P 500 index. You can later expand and customize you project to suit your needs. You will use the Python packages numpy, scipy and sqlite3, among others.
Project Description - Build a Momentum-Based Algorithmic Trading Program
Project Rubric - Build a Momentum-Based Algorithmic Trading Program
-
Part 08 : Congratulations!
Congratulations on finishing your program!
-
Module 01: Congratulations!
-
Lesson 01: Congratulations!
Congratulations on your graduation from this program! Please join us in celebrating your accomplishments.
-