Academic Databases
Explore Our Semantic Databases
STEM & Tech
Math, Physics, CS & Engineering...
Economics
Macro, Micro, Econometrics...
Business
Management, Marketing, Finance...
Health & Life Sciences
Biology, Medicine, Neuroscience...
Humanities & Social Sciences
Psychology, Law, Philosophy, History...
General Studies
General & interdisciplinary studies...
Explore Topics
Features

Multivariate Time Series Forecasting with LSTM in PyTorch | Tutorial

Added: 2026-08-07

Deep Dive

Basic concepts of Recurrent Neural Networks (RNNs) and the architecture of Long Short-Term Memory (LSTM) networks, including cell states and gating mechanisms.

LSTM Recurrent Neural Network (RNN) | Explained in Detail

LSTM Recurrent Neural Network (RNN) | Explained in Detail

124.3K

LSTM addresses RNN limitations through a sophisticated dual-state architecture featuring: (1) Cell state (Ct) - the long-term memory component that retains information across many time steps; (2) Hidden state (ht) - serving similar functions to traditional RNN hidden states. The architecture employs three gates: (a) Forget gate - element-wise multiplication with previous cell state to decide what information to retain or discard; (b) Input gate - controls addition of new information via candidate values; (c) Output gate - determines what information to output. This design enables selective information preservation and modification, solving the vanishing gradient problem by allowing gradients to flow unimpeded through the cell state.

Click to watch →

Recurrent Neural Networks (RNNs and LSTMs) architecture in deep learning #deeplearning

Recurrent Neural Networks (RNNs and LSTMs) architecture in deep learning #deeplearning

130.8K

Long Short-Term Memory networks solve the vanishing gradient problem by introducing three specialized gates and one cell state that work together: (1) Forget gate - determines what information to discard from the cell state; (2) Input gate - controls what new information to store in the cell state; (3) Output gate - regulates what information to output based on the cell state. Each gate uses a sigmoid activation function to produce values between 0 and 1, which are then multiplied element-wise with other components. The cell state carries information through time, while the gates control the flow of information into, out of, and within the cell state.

Click to watch →

Long Short-Term Memory (LSTM) Neural Networks In Arabic | شرح بالعربي

Long Short-Term Memory (LSTM) Neural Networks In Arabic | شرح بالعربي

20.4K

LSTM (Long Short-Term Memory) networks solve two critical RNN limitations: short-term memory (inability to retain information over long sequences) and vanishing gradient (gradients becoming too small for learning). The architecture introduces a cell state (memory highway) and three gates. The forget gate determines what to discard from the cell state using sigmoid (0=complete forget, 1=complete retention). The input gate controls new information addition, combining an input gate (sigmoid) and candidate gate (tanh) to decide both which values to update and what new values to add. The cell state update combines old state (modified by forget gate) with new information: Ct_new = (Ct_old × ft) + (it × Ct_candidate). This selective mechanism enables information to flow unchanged across time steps while allowing controlled forgetting and addition of relevant context.

Click to watch →

Курс NLP. Лекция 4. Часть 1.Рекуррентные нейронные сети

Курс NLP. Лекция 4. Часть 1.Рекуррентные нейронные сети

108

Long Short-Term Memory (LSTM) networks address gradient problems through a sophisticated gating mechanism. Unlike classical RNNs with a single hidden state, LSTMs maintain two states: the hidden state (H) and the cell state (C). The cell state serves as a 'memory highway' that can carry information across many time steps with minimal modification. Three gates control information flow: the forget gate determines what information to discard from the previous cell state, the input gate determines what new information to add, and the output gate determines what information to output as the hidden state. Each gate produces values between 0 and 1 using sigmoid activation, enabling the network to learn when to remember and forget information.

Click to watch →

[AI프로그래밍 16강] Recurrent Neural Networks 2 (순환 신경망 2)

[AI프로그래밍 16강] Recurrent Neural Networks 2 (순환 신경망 2)

100

LSTM (Long Short-Term Memory) was introduced in 1997 by Hochreiter and Schmidhuber to address the vanishing gradient problem in RNNs. LSTM introduces a new cell state (CT) that serves as long-term memory, separate from the hidden state (HT) which serves as short-term memory. The cell state is updated by adding the product of the input gate and a candidate value to the previous cell state. The hidden state is computed as a combination of the cell state and the previous hidden state. LSTM uses three gates: the forget gate determines how much of the previous cell state should be retained (using sigmoid activation and element-wise multiplication), the input gate determines how much new information should be added to the cell state (using sigmoid activation), and the output gate determines how much of the cell state should be exposed to the output (using sigmoid activation). The LSTM equations are: FT = σ(Wf·[HT-1, XT] + bf), IT = σ(Wi·[HT-1, XT] + bi), CT = FT ⊙ CT-1 + IT ⊙ tanh(Wc·[HT-1, XT] + bc), HT = OT ⊙ tanh(CT), where σ is sigmoid, ⊙ is element-wise multiplication, and [·,·] denotes concatenation. The key advantage of LSTM is that the cell state is updated by adding terms, which means gradients can flow backward through time without being multiplied by the weight matrix at each step, preventing the gradient from vanishing or exploding.

Click to watch →

Deep Dive

Fundamentals of the PyTorch framework, specifically tensor operations, building custom neural network modules, and the standard training loop.

Семинар. Введение в PyTorch

Семинар. Введение в PyTorch

16.2K

PyTorch is one of the most popular deep learning frameworks today, chosen for its convenience, informative documentation, and widespread adoption. The fundamental data structure in PyTorch is the tensor, which is analogous to NumPy arrays and serves as the basis for all neural network computations. Tensors can be created from Python lists using torch.tensor(), or with specific values using torch.zeros() and torch.ones(). Identity matrices are created with torch.eye(). Element-wise operations like addition and matrix multiplication (using @) work on tensors. Tensors can be converted to NumPy arrays using .numpy() and vice versa. The .item() method extracts scalar values from single-element tensors. Neural networks are built using torch.nn modules. Linear layers (fully connected layers) are created with torch.nn.Linear(in_features, out_features, bias=True), where in_features and out_features specify input and output neuron counts. The bias parameter determines whether a bias vector is included. Linear layers have learnable weights (matrix) and bias (vector) parameters, both with require_grad=True by default. Activation functions like ReLU and sigmoid are applied element-wise to introduce non-linearity. Neural networks are defined by creating classes that inherit from torch.nn.Module, implementing __init__() for architecture and forward() for data flow. PyTorch uses automatic differentiation (autograd) to compute gradients automatically. When operations are performed on tensors with require_grad=True, PyTorch builds a computation graph. Calling .backward() on the loss tensor triggers autograd to compute gradients of the loss with respect to all learnable parameters. The training loop consists of three key steps: forward pass, backward pass, and parameter update.

Click to watch →

Building makemore Part 3: Activations & Gradients, BatchNorm

Building makemore Part 3: Activations & Gradients, BatchNorm

464.3K

PyTorch builds neural networks using modular components: Linear layers (torch.nn.Linear), BatchNorm1d, Tanh, and custom modules. Each module contains parameters and implements forward() methods. Training loops iterate through data, perform forward passes, compute loss, retain gradients, execute backward passes, and apply optimizers. This modular structure enables building complex architectures by stacking predefined layers.

Click to watch →

PyTorch Tutorial 02 - Tensor Basics

PyTorch Tutorial 02 - Tensor Basics

318.3K

This comprehensive section covers the foundational aspects of PyTorch tensors. Everything in PyTorch operates on tensors, which can have multiple dimensions (1D vectors, 2D matrices, 3D tensors, etc.). Key creation methods include torch.empty() for uninitialized tensors, torch.rand() for random values, torch.zeros() and torch.ones() for initialized values, and torch.tensor() for constructing from Python lists. Tensors support various data types including float32 (default), int, double, and float16. The .size() method reveals tensor dimensions, and .dtype shows the data type. Fundamental operations include element-wise addition, subtraction, multiplication, and division using either function calls (torch.add(), torch.sub(), etc.) or operator overloading (+, -, *, /). In-place operations use underscores (e.g., y.add_(x)). Slicing follows NumPy syntax: x[:, 0] gets all rows of column 0, x[1, :] gets row 1, and x[1, 1] gets a specific element. The view() method reshapes tensors while preserving data, requiring total elements to remain constant. Use -1 as a placeholder dimension for automatic calculation. The .item() method extracts scalar values from single-element tensors. These fundamentals form the core of PyTorch programming.

Click to watch →

Семинар. Модули в PyTorch

Семинар. Модули в PyTorch

24.3K

В PyTorch можно создавать кастомные нейронные сети, наследуясь от класса nn.Module, где необходимо переопределить метод forward() для определения прямой прогонки данных, а backward() автоматически вычисляется на основе архитектуры сети; для обучения требуется функция потерь (например, cross-entropy для классификации), оптимизатор, и важно использовать nn.Parameter() для создания обучаемых параметров, которые будут автоматически отслеживаться моделью.

Click to watch →

DL Gen AI - Live Session | Quiz1 Revision coding

DL Gen AI - Live Session | Quiz1 Revision coding

331

This video covers essential PyTorch concepts including tensor shape manipulation (squeeze, reshape), data type conversion (int to float), gradient computation with autograd, and the standard training loop pattern (zero_grad, forward, backward, step). It also explains inference mode vs training mode, data augmentation practices, and how to calculate output shapes for convolutional layers using the formula: floor((input + 2*padding - kernel)/stride) + 1. The session demonstrates how to implement multi-layer perceptrons for image classification, including flattening, linear layers, and activation functions, while emphasizing proper batch processing and validation procedures.

Click to watch →

Deep Dive

Core time series analysis concepts, such as temporal sequencing, lag features, windowing techniques, and avoiding data leakage during splits.

18. How to avoid Data leakage

18. How to avoid Data leakage

502

Time series data has a special property where observations are ordered chronologically. Random splitting is inappropriate because it might include future data in training and past data in testing, causing data leakage. For time series, you must split chronologically - using earlier data for training and later data for testing. The instructor demonstrates how to use time series split functions that ensure the training data always precedes the test data in time.

Click to watch →

E159 - Data Leakage en Machine Learning

E159 - Data Leakage en Machine Learning

132

Temporal leakage occurs when you divide time series data randomly between training and test sets. For example, if you randomly split a time series, you might include future data in the training set. This is problematic because time series data has temporal dependencies - you should only use past data to predict future data. The correct approach is to split time series data chronologically, using an earlier time period for training and a later time period for testing.

Click to watch →

Прикладные задачи анализа данных — семинар 6 (ИАД-2)

Прикладные задачи анализа данных — семинар 6 (ИАД-2)

261

Time series data preparation involves converting raw data into a format suitable for modeling, including specifying frequency, defining target variables, timestamps, and segments. The instructor demonstrates how to generate descriptive statistics and visualize data automatically. Time series data requires chronological train-test splitting to avoid data leakage, unlike random splitting in standard machine learning. Lag features are historical values used as input features, where a lag of 1 means using the value from one time step ago, and a lag of 12 means using the value from 12 time steps ago. For monthly data, a lag of 12 corresponds to one year.

Click to watch →

8. Time Series Analysis and Forecasting in Machine Learning with Andrey Holz, Ph.D.

8. Time Series Analysis and Forecasting in Machine Learning with Andrey Holz, Ph.D.

2.9K

Proper data splitting prevents data leakage. Simple approach: train on past data, test on future data (e.g., train on first 8 years, test on last 2 years). Time-based cross-validation methods: (1) Rolling window - training set expands over time (fold 1: train on year 1, test on year 2; fold 2: train on years 1-2, test on year 3, etc.), (2) Sliding window - both train and test sets move forward maintaining fixed size, useful when system behavior changes over time. Always maintain temporal order and ensure test set contains future data unseen during training.

Click to watch →

Markus Loning - Introduction to Machine Learning with Time Series | PyData Fest Amsterdam 2020

Markus Loning - Introduction to Machine Learning with Time Series | PyData Fest Amsterdam 2020

24.4K

A major pitfall is data leakage when using standard scikit-learn train_test_split, which shuffles data randomly. In time series, observations depend on past observations, so random shuffling causes training data to contain information about the test period. The solution is temporal train test split (shuffle=False). Another pitfall is confusing single-step with multi-step ahead predictions. Tabularization (sliding windows) creates feature matrices where each row is a window and the target is the subsequent value, but this approach requires careful implementation to avoid optimistic performance estimates. The resulting format allows any scikit-learn regressor to be applied, but requires careful implementation of the windowing strategy.

Click to watch →

Deep Dive

Data preprocessing workflows in Python using Pandas and Scikit-Learn, particularly MinMax scaling or standardization for neural networks.

Feature Engineering Techniques For Machine Learning in Python

Feature Engineering Techniques For Machine Learning in Python

45.4K

This section covers essential data preprocessing techniques for machine learning. It explains feature scaling methods: StandardScaler standardizes by removing mean and scaling to unit variance, MinMaxScaler scales to 0-1 range, and Normalizer scales each sample to unit norm. Different algorithms have varying sensitivity to scaling—tree-based methods are relatively insensitive while neural networks require careful scaling. The section introduces Scikit-learn's Pipeline for automating sequential transformations (scaling, PCA, modeling) into a single object, preventing data leakage. For categorical variables, pandas' get_dummies() creates dummy/one-hot encoded binary columns where each category becomes a separate feature. This encoding assumes mutual exclusivity among categories. The pipeline approach enables systematic comparison of different preprocessing strategies while maintaining methodological rigor throughout the machine learning workflow.

Click to watch →

Escalamiento, Normalización y Estandarización de Datos con Python para Ciencia de Datos

Escalamiento, Normalización y Estandarización de Datos con Python para Ciencia de Datos

57.6K

Scikit-learn's preprocessing module provides four key transformers for data homogenization: (1) MinMaxScaler scales data to a fixed range using min and max values; (2) Normalizer applies L2 vector normalization to compress magnitudes; (3) StandardScaler standardizes data to zero mean and unit variance; (4) RobustScaler uses interquartile range for outlier resistance. Each implements fit_transform() to process raw data into standardized arrays. These tools address the critical need to make features comparable before applying machine learning algorithms that assume similar input scales.

Click to watch →

Feature Scaling in Machine Learning | When to use what? | Standard Scaler vs Min-Max Scaler

Feature Scaling in Machine Learning | When to use what? | Standard Scaler vs Min-Max Scaler

140

To implement MinMaxScaler: (1) Import MinMaxScaler from sklearn.preprocessing, (2) Create a scaler object with range parameter (default 0-1, can be set to -1 to 1), (3) Fit and transform training data, (4) Apply transform() to test data. Key differences: StandardScaler produces mean 0, std 1 and handles outliers better; MinMaxScaler produces fixed range (0-1 or -1 to 1) and is sensitive to outliers. StandardScaler suits SVMs, PCA, and linear models; MinMaxScaler suits neural networks and CNNs.

Click to watch →

Day 4-Practical ANN Impementation| Live Deep Learning Community Session

Day 4-Practical ANN Impementation| Live Deep Learning Community Session

70.7K

StandardScaler normalizes data using z-score transformation (mean=0, std=1), which centers the data around the mean with unit variance. MinMaxScaler scales data to a fixed range, typically [0,1] or [-1,1]. StandardScaler is preferred for neural networks because it handles outliers better and allows the model to learn meaningful patterns from the data distribution.

Click to watch →

Scikit Learn Tutorial | Scikit-Learn Workflow | Data Preprocessing In Machine Learning | Intellipaat

Scikit Learn Tutorial | Scikit-Learn Workflow | Data Preprocessing In Machine Learning | Intellipaat

105.9K

The scikit-learn machine learning workflow follows a consistent pattern: data is split into features (X) and target variables (Y), a model is created and trained using the .fit() method, and predictions are made using .predict(). Data preprocessing involves several key steps including handling missing values through imputation (using mean, median, or most frequent strategies), feature engineering to create meaningful predictors from raw data, encoding categorical variables using techniques like one-hot encoding, and scaling numerical features using methods such as StandardScaler or MinMaxScaler to ensure all features contribute equally to the model's learning process.

Click to watch →

Data Prep

Data Module

LSTM Model

Lightning Module

Train Callbacks

Predict & Scale

Result Plot

Data Prep

0:00

Playing Section

1
Sets up GPU and installs necessary libraries for model building.
2
Completes data preprocessing and sets sequence length to 120 minutes.

Deep Dive

Exploring advanced deep learning architectures for time series, such as Attention-based models, Transformers (e.g., Temporal Fusion Transformer), and Temporal Convolutional Networks (TCNs).

ACML2020 Tutorial Forecasting for Data Scientists Christoph Bergmeir

ACML2020 Tutorial Forecasting for Data Scientists Christoph Bergmeir

8.2K

Deep learning adapts NLP architectures (LSTMs, CNNs, Transformers) to time series forecasting. Key differences from NLP: recent observations matter more than distant ones, and long-term dependencies are usually simple (seasonal patterns). LSTMs with input/output windows work better than pure recurrent architectures. CNNs with causal convolutions and dilations achieve comparable results faster. Specialized architectures include DeepAR (generative model), DeepState (parameterized state-space models), DeepFactors (factor decomposition), Neural Basis Expansion Analysis (NBEATS), and Temporal Fusion Transformers. Multivariate forecasting remains challenging for large hierarchies.

Click to watch →

Time Series Forecasting - Modern Methodologies. N-BEATS and TimesNet , Exponential Smoothing (ETS)

Time Series Forecasting - Modern Methodologies. N-BEATS and TimesNet , Exponential Smoothing (ETS)

138

Three deep learning architectures address industrial forecasting challenges: (1) Deeper pioneered global learning from millions of time series using LSTM with negative binomial likelihood and weighted sampling to handle power-law distributed sales data; (2) Temporal Fusion Transformer handles three input types (static covariates, known future inputs, observed data) with gating layers and static encoders for interpretability; (3) ETSformer bridges classical statistics and deep learning using decomposition with residual learning and specialized attention mechanisms (ESA, FA) for efficiency. These models generate probabilistic forecasts through ancestral sampling, achieving ~15% improvements over traditional methods while providing uncertainty quantification essential for risk management.

Click to watch →

시계열 데이터를 위한 딥러닝 기본구조

시계열 데이터를 위한 딥러닝 기본구조

706

Time series data, which changes over time (e.g., stock prices, audio, brain waves), can be processed using specialized deep learning architectures: 1D CNN extracts local temporal features through adjacent element connections, LSTM captures sequential dependencies with gating mechanisms for long-term memory, and Transformer uses attention mechanisms with positional encoding for parallelizable sequence learning; these layers reduce parameters compared to fully connected layers by making specific assumptions about temporal relationships, and can be combined in networks like CNN-LSTM for comprehensive time series analysis.

Click to watch →

Deep learning para predicción de series temporales

Deep learning para predicción de series temporales

7.2K

Deep learning models for time series forecasting include Multi-Layer Perceptron (MLP), Elman Recurrent Neural Network (RNN), Long Short-Term Memory (LSTM), Gated Recurrent Unit (GRU), Convolutional Neural Network (CNN), and Temporal Convolutional Network (TCN), each with distinct advantages: RNNs handle variable-length sequences and maintain temporal order, LSTMs solve vanishing gradient problems through forget/update/output gates, GRUs offer faster training with fewer parameters, CNNs extract local patterns through 1D convolutions, and TCNs use dilated convolutions to capture long-range dependencies efficiently.

Click to watch →

Deep learning research @Nvidia, time series, GNN with Kyle Kranen - The Data Scientist Show#028

Deep learning research @Nvidia, time series, GNN with Kyle Kranen - The Data Scientist Show#028

2.4K

Temporal Fusion Transformers (TFT) combine attention mechanisms with traditional recurrent encoder-decoder frameworks for multi-horizon time series forecasting. The architecture includes a variable selection network that identifies important features at the input stage, providing direct interpretability about which features contribute to predictions. Additionally, attention mechanisms enable temporal interpretability, showing which past time steps most influence current predictions—a capability absent in simpler models like ARIMA or basic tree ensembles.

Click to watch →

Deep Dive

Implementing robust validation and backtesting frameworks, such as walk-forward cross-validation, specifically tailored for financial market datasets.

Learn Backtesting Trading Strategies: Step By Step Process With Walk Forward Testing | Quantreo

Learn Backtesting Trading Strategies: Step By Step Process With Walk Forward Testing | Quantreo

1.1K

Walk forward optimization solves the variance problem inherent in standard train/test splits by using multiple overlapping training and test periods instead of single splits. This approach provides more reliable performance estimates by reducing dependence on arbitrary split points. Complementing this is robustness testing using CPCV methodology, which calculates overfitting probability and degradation between training and test periods. Together, these techniques create a framework where strategies must first demonstrate quality through walk forward optimization, then prove reliability through robustness testing before proceeding to live deployment.

Click to watch →

I Tested 350,000 Bitcoin Strategies. 4 Survived.

I Tested 350,000 Bitcoin Strategies. 4 Survived.

633

Most trading strategies that appear successful in backtesting are products of optimization on historical data rather than genuine edge. When you take enough indicators, parameter combinations, and assets, something will eventually fit the past. This fit looks like edge but isn't real. Walk-forward validation addresses this by testing strategies on data they were never optimized on. The data is split into five sequential windows, optimized on training portions, and applied blind to out-of-sample portions. The combined curve from all five out-of-sample periods represents the honest result.

Click to watch →

The Earnings Volatility Strategy Big Funds Use (That You Don't Know About)

The Earnings Volatility Strategy Big Funds Use (That You Don't Know About)

13.7K

Proper out-of-sample validation uses walk-forward optimization with expanding windows: fitting models on 2009-2010, trading on 2011-2012, expanding to 2009-2012, trading on 2013-2014, and repeating. Across all windows, coefficients maintained consistent signs and magnitudes, with positive out-of-sample correlation and top-minus-bottom decile spreads. Filtering trades to predicted return > 0 improved mean return from 0.3% to 3.3%, median from -6.3% to -3.6%, and win rate from 37% to 42%. Kelly fraction came to ~48.5%, but full Kelly is impractical. Backtests with different fractions showed decreasing Kelly improves Sharpe ratios and reduces drawdowns, demonstrating the trade-off between return and risk.

Click to watch →

Weather Prediction With Python And Machine Learning [W/Code]

Weather Prediction With Python And Machine Learning [W/Code]

97.6K

Standard cross-validation techniques cannot be directly applied to time series data because they risk using future information to predict past values. Backtesting (or time series cross-validation) preserves temporal order by training on earlier data and testing on later data. The approach involves: (1) defining a warm-up period (e.g., 10 years), (2) iteratively creating training sets from data up to each point, and (3) creating test sets from the next fixed interval (e.g., 90 days). This ensures predictions respect the chronological nature of the data.

Click to watch →

14-12 Кросс валидация для временных рядов в python

14-12 Кросс валидация для временных рядов в python

2.5K

Walk-Forward Validation is designed for short-term forecasting where the model predicts one observation ahead, then retrains with the revealed value. It can be implemented using Pandas' rolling window functions with either expanding or rolling window approaches. Both methods yield similar quality metrics (e.g., MAPE ~3.2%). Critical principles for time series cross-validation include respecting temporal structure and ensuring test data never contains future information relative to training data. This prevents data leakage and produces valid evaluation results that reflect real-world prediction scenarios.

Click to watch →

Deep Dive

Feature engineering with domain-specific indicators, such as technical analysis indicators (MACD, RSI) and alternative data (sentiment analysis from news or social media).

Krypto: Wenn DU das im Chart siehst, ist es ZU SPÄT...!

Krypto: Wenn DU das im Chart siehst, ist es ZU SPÄT...!

22.6K

This segment covers technical indicators used for market analysis including MACD and RSI. The speaker explains that MACD helps identify trend direction and potential reversals, with decreasing values indicating market consolidation. RSI measures momentum and identifies overbought or oversold conditions, with readings below 30 indicating oversold and above 70 indicating overbought. The speaker also discusses Open Interest, which represents outstanding derivative contracts and indicates market sentiment. When Open Interest increases significantly, it suggests more leveraged positions are entering the market, which can signal strong market sentiment or potential overhyping.

Click to watch →

Bitcoin BTC Price News Today - Technical Analysis and Elliott Wave Analysis and Price Prediction!

Bitcoin BTC Price News Today - Technical Analysis and Elliott Wave Analysis and Price Prediction!

6.3K

This segment provides an in-depth analysis of technical indicators for Bitcoin. The presenter explains that short positions have increased massively, suggesting contrarian trading opportunities. The RSI analysis reveals that Bitcoin's RSI has never been as low as current levels (around 40), with the lowest historical reading being 44.45, indicating oversold conditions. The monthly MACD analysis shows the indicator has moved from high positive territory into negative territory, with the histogram showing reversal patterns. The presenter explains that when MACD was previously high, it limited price reversal potential because the indicator would have become exhausted quickly. The weekly MACD shows indecisive signals with negative momentum still increasing but slowing down. The daily MACD is also oversold but not yet turning around. The presenter emphasizes that the monthly MACD histogram reduction in negative momentum is a positive sign that market conditions may be changing.

Click to watch →

MACD İndikatörü Nasıl Kullanılır / RSI İndikatörü Nasıl Yorumlanır

MACD İndikatörü Nasıl Kullanılır / RSI İndikatörü Nasıl Yorumlanır

126K

This video explains three essential technical analysis indicators used in trading: (1) Moving Averages (Simple, Weighted, and Exponential) which smooth price data to identify trends and generate buy/sell signals through crossovers; (2) RSI (Relative Strength Index) which measures price momentum and identifies overbought (above 70) and oversold (below 30) conditions, functioning as dynamic support/resistance levels and revealing divergences when price and indicator move contrary; (3) MACD (Moving Average Convergence Divergence) which combines two EMAs with a histogram to show trend strength and generate crossover signals. The instructor emphasizes that no single indicator is perfect and should be used as辅助 tools rather than standalone decision-making mechanisms.

Click to watch →

BORSA EĞİTİMİ - DERS : 3 - RSI ve MACD | #teknikanalist #teknikanaliz #borsa #borsaeğitimi

BORSA EĞİTİMİ - DERS : 3 - RSI ve MACD | #teknikanalist #teknikanaliz #borsa #borsaeğitimi

40.2K

The RSI (Relative Strength Index) measures overbought and oversold conditions on a 0-100 scale, where values below 30 indicate oversold territory and values above 70 indicate overbought territory, serving as short-term trading signals; the MACD (Moving Average Convergence Divergence) is a trend-following indicator based on the difference between 12-day and 26-day exponential moving averages, generating buy/sell signals when the MACD line crosses the signal line, with signals above zero being more reliable than those below zero; both indicators should be used in combination with moving averages and other technical tools rather than in isolation to avoid false signals.

Click to watch →

How to Swing Trade Stocks (THE BASICS)

How to Swing Trade Stocks (THE BASICS)

179.2K

Two primary technical indicators help swing traders. MACD (Moving Average Convergence Divergence) shows momentum through the relationship between short-term and long-term moving averages. The histogram above zero indicates buying pressure (green bars increasing, red bars decreasing), while below zero indicates selling pressure. RSI (Relative Strength Index) examines 14 trading days, comparing gains to losses. Values of 70-100 indicate overbought conditions (potential pullback), while 0-30 indicate oversold conditions (potential snapback). Values between 30-50 indicate normal downtrends, and 50-70 indicate normal uptrends. These indicators are not guarantees but provide probabilistic signals.

Click to watch →

Deep Dive

Deploying the trained PyTorch model into a real-time inference pipeline or automated trading system using APIs (e.g., FastAPI) and model export tools (e.g., ONNX or TorchScript).

Mastering PyTorch for Production: From Tensors to Deployment at Scale

Mastering PyTorch for Production: From Tensors to Deployment at Scale

417

Production deployment requires serializing models for portability: TorchScript (tracing for static models, scripting for dynamic control flow), ONNX for cross-platform interoperability with multiple inference engines (TensorRT, OpenVino, ONNX Runtime). Serving solutions include TorchServe (official PyTorch solution with REST/gRPC endpoints, versioning, batching), FastAPI (flexible custom APIs with Pydantic validation), and Nvidia Triton (high-performance multi-framework GPU serving). Model signatures in MLFlow enable input validation at deployment, catching malformed requests early.

Click to watch →

How To Deploy PyTorch Models Using ONNX? - AI and Machine Learning Explained

How To Deploy PyTorch Models Using ONNX? - AI and Machine Learning Explained

192

To deploy PyTorch models across different platforms, export them to the Open Neural Network Exchange (ONNX) format by first setting the model to inference mode using model.eval(), then using torch.onnx.export() with a dummy input tensor matching the model's expected input shape, and finally verifying the exported model using ONNX runtime tools before deploying it with high-performance inference engines like ONNX Runtime or Triton Inference Server.

Click to watch →

Build and Deploy Plant Disease Classifier with Huggingface Transformers, Onnx and FastAPI

Build and Deploy Plant Disease Classifier with Huggingface Transformers, Onnx and FastAPI

132

This comprehensive section covers deploying machine learning models in production environments: (1) Understanding ONNX as an open format for model interoperability across frameworks (PyTorch, TensorFlow, Keras, MXNet), (2) Installing ONNX and ONNX Runtime libraries for efficient inference, (3) Converting PyTorch models to ONNX format using torch.onnx.export with dummy inputs and proper configuration, (4) Setting up dynamic axes for variable batch sizes, (5) Preprocessing images for ONNX inference including resizing, transposing dimensions, and normalization, (6) Creating ONNX Runtime sessions with appropriate execution providers (CPU/CUDA), (7) Building FastAPI applications for model serving, (8) Implementing lifespan context managers for efficient resource management, (9) Creating image upload endpoints, (10) Building inference endpoints that run ONNX models, and (11) Testing deployed APIs using built-in documentation interfaces.

Click to watch →

Convert Any PyTorch Model to ONNX and Serve via Flask API

Convert Any PyTorch Model to ONNX and Serve via Flask API

26.7K

This tutorial demonstrates how to convert PyTorch models to ONNX format using the torch.onnx.export() function, which requires specifying input shapes, input names, output names, and dynamic axes for variable batch sizes; the converted ONNX model can then be served via a Flask API using onnxruntime for inference, enabling cross-platform deployment and easier model sharing across different environments.

Click to watch →

Deploy Pytorch Models with FastAPI using Google Colab

Deploy Pytorch Models with FastAPI using Google Colab

7.1K

This tutorial demonstrates how to deploy pre-trained PyTorch models (such as the DPT Large depth estimation model) as web APIs using FastAPI in Google Colab, leveraging Ngrok for public URL access and nest-asyncio for asynchronous task execution, enabling rapid prototyping and demonstration of AI models without complex infrastructure setup.

Click to watch →

Data Prep

Data Module

LSTM Model

Lightning Module

Train Callbacks

Predict & Scale

Result Plot

Data Prep

0:00

Playing Section

1
Sets up GPU and installs necessary libraries for model building.
2
Completes data preprocessing and sets sequence length to 120 minutes.

45.7K views79046:03@venelin_valkovOriginal Release: 2021-03-30

This tutorial demonstrates how to build a Long Short-Term Memory (LSTM) neural network for predicting Bitcoin prices from multivariate time series data using PyTorch and PyTorch Lightning. The process involves converting raw time series data into sequences, creating a custom PyTorch Dataset class, implementing a PyTorch Lightning DataModule for training and testing splits, defining an LSTM model architecture with configurable hidden units and layers, and training the model with callbacks for early stopping and model checkpointing. The tutorial emphasizes proper data preprocessing including MinMax scaling and inverse transformation for accurate evaluation, showing how to visualize predictions against actual prices to assess model performance on financial time series forecasting tasks.

[00:00:00]hey guys in this video we are going to continue with the bitcoin price forecasting example and more specifically we are going to build a simple lstm model which predicts the next price or next minute price for bitcoin let's get started so here we have exactly the same notebook that we left off last time and currently i'm going to change the run type to a gpu save that and after that i'm going to reconnect or connect to the instance and i'm going to check what type of gpu do i get and in our example this will be 80 let me just try out this one more time check it and after this runs i'm going to change basically some of the imports so still cry 80 unfortunately but that's all right i'm going to install by torch lightning and the latest or some of the latest version of tqdm and in here i'm going to add multiple slip model checkpoint and early stopping from pytorch whitening because we are going to use those and basically after that i will run this and this is again exactly the same thing that we had before running through the data i'm going to complete the pre-processing steps and next i'm going to just change the sequence length because i basically found that the longer the sequence is the better the predictions get and uh in our example we're going to use 120 minute data from the history of the model so i'm going to run all of this and we will be back after everything is executed all right so the execution is basically done and as you can see it took about 40 or 50 seconds something like that uh to complete the sequences and this is the amount of data that we have for training and test sequences next i'm going to show you how you can basically convert all of this into a pi torch data set and to do that i'm going to create a new class called btc data set which are is going to extend from python data set and basically we're going to override the two required methods which is the length and the get item method so i'm going to define this and this will take as a parameter sequences on which it's going to operate i can try today sequences all right and after that i'm going to overwrite the length method and this will basically return the number of sequences that we have in our example then i'm going to overwrite the get item method which uh takes as an argument the current index that we are interested in and from the sequences i recall that we are basically storing the data in those as a tuple and the first item of this tuple is the sequence and the next item is the label so i'm going to expand this tuple right now and take the sequence at the current index and finally i'm going to return a dictionary which contains two tensors the first one is going to be the tensor containing the sequences or the sequence data and the next one is going to be the label which again is the bitcoin price that we are interested in predicting so i'm going to convert the sequence from uh numpy array uh basically i'm going to convert it from uh pandas data frame to numpy array and i'm going to wrap this into pie torch tensor constructor and for the label we have another tensor which is going to take the label but i'm going to convert this into a volt because we are doing regression and we are interested in predicting a floating point number uh next i'm going to wrap or erupt all this into by torch whitening data module and to do that i'm going to create a class called uh ptc price data module which is going to basically split that um so it's going to create two data sets one for training and one for testing is going to take the training and testing sequences and then create waters basically for those and again we're in uh extending pl whitening data module right here again we need a constructor and in here i'm going to pass in the train sequences the test sequences and the batch size and we're going to put a sample value of 8 or whatever but we are going to change that in a bit and next i want to basically go here call the super method so we're calling the super constructor of the whitening data module and i'm going to store the sequences into fields of this class and i'm going to store the bot size as well today i can't write all right so i like to create this method called setup which we are going to call right after creating an instance of this class and this is going to basically convert the sequences into a btc data set i'm going to pass in the train sequences and i'm going to do basically the same thing for the test sequences all right so next we want to overwrite the three methods train data water which of course is going to return a data order for the training uh part of the the evaluation and training process then we are going to do the same thing for the validation water and test water and the validation and test water in our example are going to contain exactly the same data you are free to to change this and create test and validation sets for your examples but uh here i'm more interested in giving you up somewhat of an engineering approach of how to basically structure your whole project when you have to do some time series forecasting with an ostm or another model so i'm going to overload the train date order and i'm going to return a data waller and here i'm going to pass in the training data set as the first parameter and the batch size actually is going to be the bar size that we passed on i don't want this to be shuffled uh because this is um time series data and actually the time series data has a component of time which might be of importance when the model is warning all of this i think that there are there are some arguments against uh shifting and some arguments for shift link i think that you should do a research on your own and probably do an experiment or two uh on which works best for your project but i'm not going to shuffle the the data and i'm going to specify the number of workers this will essentially allow us to to vote the data a bit faster compared to a single worker and this will again depend on the machine that you have and currently we have this google co-op instance so yeah we are still not using the gpu that's right and then i'm going to create a validation loader and here we again have the data waller and this one takes the test data set and the patch size for this is going to be one and this will be very similar to how we are doing inference in the real world we most likely passing just a single example so this is the validation data order and i'm going to do exactly the same thing for the test date waller after this is done i'm going to execute this cell so we have the btc price data module and the btc data set everything uh is looking all right next i'm going to define the number if epochs for which we are going to train the model and the batch size and basically all those parameters are going to be defined based on the project that you have and the the machine that you have as well so you must probably you can start with those numbers and then continue on and fine-tune them based on your project i'm going to create an instance of the data module and i'm going to pass in the training sequences the test sequences and the patch size which is going to be the constant that we created here the path size and then after the module is created i'm going to call the setup method which is going to again create those data sets all right so i want to basically show you what a single item from this data set contains so you can get a better view of what is in the data and if i create this train data set and i start iterating over it i'm going to put on a break right here and if i output the item sequence and its shape and this is okay because if you recall we are returning from our data set class right here we are returning a dictionary which contains a sequence and a label and both of those are actually tensors so this should work and i'm going to do exactly the same thing for the label and i'm going to print out the label i'm not going to print out the sequence itself because that will be a very large output and here we have the label shape so as you can see this is a tensor that contains just a single item and we'll have to basically deal with this a bit later on and we have the label itself and recall that this is a scaled price of bitcoin so this is not exactly the route date or the the real price of bitcoin all right so next i want to show you how we can build a simple model that is going to use an lstm and in here i'm going to create a constructor which is going to take the number of features that we have the number of hidden units for the lstms in particular and the number of layers again for the ostm the first thing that i'm going to do here is call the init method and then i'm going to save the number of hidden units next i'm going to initialize the lstm layer of our model and if you're not familiar sorry about that if you are not familiar with what ostms are let me show you kind of the documentation in pytorch so ostm is uh short for long shorter memory recurrent neural net and basically of course this is no way an intro to lstms or rns but in essence those type of models allows us to input some sequence of data and then maybe get a single output as the regression example that we're dealing with or maybe you want to output multiple example multiple data points for example where doing translation of text you input for example english and then as an output you get french at the french translation of the text initially ios teams were primarily used for text but then again they are very general and can handle all type of all types of sequences so in our example we are going to use those for time series uh data and i don't think that ostms are pretty much state of the art in all of the possible time series evaluations or benchmarks some time ago there were there started to introduce transformers to time series data as well as to text and images and more recently it looks like the transformers are pretty much overtaking everything i mean like even text images and probably time series data but in our example we are going to stick to the basics and hopefully in some of the next videos i'm going to show you how we can use transformers for time series data so stay tuned for that and here the documentation for the ostm is very good and very well developed they also have an example of what the lstm can take as an input and as an output and in our example i am going to first start with initializing the ostm and this takes a lot of parameters actually but i am going to give the number of features as the input size so in our example this is going to be raindiff ship so this is the number of features that we have so we have nine features so the n features in our case is going to be nine uh the hidden size is going to be and hidden this is passed as a parameter right here next i want to specify that i want to input the batch size as a first parameter to this and this will be handy because we want to have a data order that can pass in a batch of sequences and each sequence is going to contain 102 uh 120 examples let me just check where do we have this yeah so we will have 120 examples in each sequence data points and for each data point we will have nine features exactly and i'm going to show uh this exact shape later on next this can get number of layers so this will basically stack ostms on top of each other and i'm going to specify a dropout this is a way to regularize the ostms and uh using dropout in lstms is kind of bit uh tricky but when using pytorch it seems like uh it's just past this parameter and everything is sorted out for you next i want to output a single number which is going to be the prediction of our model and this will take the number of hidden units as a size for the input and we want to output a single number so the number of out features is going to be one all right so this is basically the initialization of our model uh next we are going to overwrite the forward method and this will take the a simple sequence that contains the data for the current example first thing i'm going to do is call lstm flatten parameters and i think that this should work very well even without calling this method but this should sort out the memory or the gpu memory when you're doing some distributed training so this is rather a defensive style and it should work when you are doing distributed training because again pythos whitening allows you to do distributed training and multi gpu training very easily so this should get you sorted out with that and for the output i'm going to return to the documentation here and this is basically the output of a single lstm so the first thing is going to be the features of the last layer of the ostm then we have the hidden state which is specified for each layer that we have and then the cell state for some position t or time t of the iostm and yeah those are a bit hard to understand and depending on the the problem that you have you might want to dive a bit deeper into what you want to achieve but essentially what i'm going to do is call the lstm and take out the complete hidden state of the iostm and after that i'm going to take the state of the last layer because as you can recall uh we are passing for example two layers and we want the output of the last layer so this will be the layer that contains the features that we want to pass to the to the final or to the regular regressor layer that we have all right so let's return this and i'm going to output the out from here so this is the model that we have and let me run this so next we are going to create a whitening module which is going to use this model that we have so far and here i'm going to initialize it i'm going to pass in the number of pictures and uh basically when i have something that is client facing or user friendly module i would like i sometimes or most of the time like to type hint the parameters i think this is a good practice especially in python and i'm going to init this create a model i'm going to pass in the number of features i'm going to leave all the other parameters of our model and the number of hidden units and the number of layers at their default values and i'm going to initialize the loss function and since we're doing regression i'm going to use mean squared error was right here okay so we have to basically define a couple of methods the first one is going to be the forward method and this is going to take the sequence and the labels and you'll see why in a second first i'm going to take the output of the model or the prediction for the price and i'm going to specify a wasp as 0 and i'm going to return the waves and the output and if we have labels i'm going to call the loss function and i'm going to convert the labels i am going to basically add another dimension at the end of the labels so the comparison between the output of the model dimension is going to be equal to the dimension of the labels so next i'm going to define a training step and this will take a batch for examples patch index and i'm going to take from the batch the sequence this is just from the dict that we have in our data set i'm going to take the labels then i'm going to calculate the was in the outputs and i'm going to walk the results as the training was and i'm going to return the loss so we can basically walk this all right this was for the training step and i'm going to copy and paste in the interest of time the validation step and the test step there are pretty much exactly the same except that we are logging the validation was and the test was and again we are just returning the was i think that i can actually return the words right here as well but you will see all right so the final method that we need to overwrite is configure optimizers and here pytorch whitenings requires from us to return optimizer and i'm going to pass in atom with basically weight decay fix which is very popular when or regarding or sometimes using hugging face uh transformers or the hanging face library in itself and this would require the parameters of the model and i'm going to pass in a warning crate like this and this will be pretty warm and you'll see why hopefully when we start training this and now i'm going to initialize this class with the number of features which again i'm going to show you here is going to be 9 or the first element from this array so i'm initializing it with this okay so um i'm going to do something a bit different now i want to basically take this and create a data waller to show you what is happening exactly under the hood and i'm going to take the yeah let me let me actually run over the data module brain data water method and i'm going to break here and let me just print item is if this works this is not defined oh yeah all right i have an error so i've used this let me go back check this all right all right so here we have sequence and the labels and as you can see we have the bot size which is 64 then the number of examples or data points in each sequence and then finally we have the number of features as a last uh position in this shape so everything seems to be uh doing all right and this is basically the shape that you need to pass in when you want to train this particular model and the batch first parameter that we set to true is going to respect that the first dimension of this array or tensor is going to be the number of elements in the batch so this works out pretty alright next i want to start tensorboard and i'm going to specify the directory for which it's going to what the works from whitening works and next i want to start checkpoint callback and here i am going to use model checkpoint from pytorch whitening i'm going to specify the checkpoints folder and i just want to use this checkpoint or model checkpoint callback to save the best model during training i want to save only the best one so i'll say save top k equal to one i want this to be very both so we know what is happening and i want this to monitor the validation was and i want to look for the minimum value of the validation was because we are trying to minimize it next i'm going to initialize a tensorboard lower and i'm going to specify the name of the experiment as btc price then i want to add another callback which is going to be the final one and this will be early stopping callback so what this will do is look at the validation was and if we haven't done any improvement to the validation was for the last uh two epochs the training is going to be stopped and the patience parameter is going to be the number of epochs for which we want this to happen to be stopped and then i'm going to create this trainer from pytorch whitening and i'm going to pass all those stuff as a parameters and for the max epochs we want to specify the epochs that we have defined already i want to specify that we are going to use a single gpu and the final parameter is going to be required because we are training on google co-op so this should give us something useful so it says that we have a gpu available which is correct and we are going to use it for training next i want to start the training and i'm going to pass in the model in the data module and i'm going to wait and see what is happening right here so this will basically start the entire training progress process and go over the module and going to do a validation sanity check at the start so that all the all the parameters and all of the dimensions are doing fine and unfortunately this will not be very very fast because we have this uh ca 80 in our example so what i'm going to do is basically i'm going to upload a checkpoint which is going to contain a model that i've pre-trained and yeah unfortunately i'll have to to stop this and basically what the checkpoint that i have so i'm going to do that by creating the btc price predictor called what from checkpoint and i'm going to use the best checkpoint that i've just uploaded and i'm going to specify the number of features which is going to be train gf shape one again nine features and this model i want to be freezed or frozen so it is a bit faster to create predictions so i'm going to basically go over the test data set and yeah i can actually show you the the training progress that happened during all this uh as you can see i've trained this model for around three epochs that were kind of right and the validation was has been decreasing during those and at the epoch number three and four as you can see the validation was was not improving so the early stopping callback kicked in and uh basically the training has stopped so this was the training progress that i went over and in here you can see that an epoch takes about two minutes and a half on a t4 gpu i was working there all right so now that we have this data set i'm going to initialize it and then we are going to get the predictions from our model i'm going to iterate over it i'm going to take the sequence and the label then i'm going to ignore the wash off our model and i'm going to take just the output and i'm going to unsqueeze and squeeze here in the sequence put it over here and basically i'm going to append the prediction to the predictions and i'm going to do the same thing for the labels i'm going to run this and this should take some time so i'll see you when this process has complete alright so now that this is done you can see it took about six minutes the first thing that we are going to do is check the number of predictions and compare that to the number of test data that we had and these numbers are different because we have to basically do the length of the data frame minus the sequence length and then the number of examples is going to be correct so you see why we are going to need this in a bit uh so let's just show what do we have into the test data frame and you can recall that we actually did some scaling with min max keyword and actually the close price is the scaled price the scaled cost price and the predictions of course are in this same uh scaled range so we want to inverse this scaling and to do that i'm going to use a technique that i found at stack overflow and i'm going to show you what i mean right now so uh this is yeah this is something that i found and this answer is from yeshu vishnalia i believe so this dude right here uh i think that he had the best uh answer to this and basically the question is how do we invert this scaling and uh to do that we are going to use the scaler itself and the scaler contains basically those minimum and scaled values i'm going to show what i mean right now so this is the minimum values for each of the columns that we have as features and we have the same thing for the scale parameter of the scaler all right so just to take the last values of those i'm going to do something like this and this will basically give us the scale of the close price which is great and i'm going to write a simple function based on this but first i want to create a d scaler which is going to be minmax scaler which has the parameters from the our original scaler and i'm going to overwrite the min and the scale parameters so yeah mean underscore and scale underscore so after this is done i want to write a simple function called the scale and it's going to take this keyword and some values unfortunately the minbox keyword works only with 2d data so we have to convert those values to the numpy array and i'm going to convert the values to a numpy array and then basically add a new axis or a new dimension to this array so if you guarantees us that we have at least another dimension you might want to make this function more robust but i know that the values are currently 1d so next i'm going to call inverse transform of the d scale under this keyword and i want to work on the result so we are going to pass in one dimensional array or vector and we are going to output a vector as well so i'm going to descale the predictions and the labels all right and let's look at the for example the first five examples of the predictions and yeah those look as non-scaled values i'm going to do the same thing for the labels and again those seem like that they have been altered compared to the prices that we had here so this is very good and next i want to create a plot that compares the predictions to the labels that we have so to do that i want to take the original test data because i need the date time from it and i'm going to basically redo the split of the test data and i'm going to check that the length of the test data frame and the test data are exactly the same so this is uh all right but recall that the tray the test sequences must exclude the first amount of test of sequence lengths so just to take the data for that i'm going to take everything after the initial sequence length and this will guarantee us sequences data this will guarantee us that guarantee this guarantees us that we have the same number of data points here or the dates that we have into the test sequences themselves and i'm going to show you the test sequences data here which again is the original number uh the original data that we had so this looks pretty good i'm going to basically take this com right here from that data so how i'm going to put this first i want to use matpotlib to convert the dates numbers and i'm going to take the column date and convert it to a list so this will basically do a date conversion to numbers which we are going to plot right now and matplotlib by pywap has a plot date method or function which i'm going to pass the dates to that the predictions this code i want to draw this one to draw a line and i'm going to say that those are the predicted labels predictions i'm going to pass in the real prices i want the ticks on the x-axis to be rotated and i want to show a legend of this so if we put this we are going to see the result of the model so here in yellow we have the real price of the bitcoin for these dates uh basically this exact month march that we have right now and these are the predicted prices as you can see at least at the beginning it looks like the model is doing quite an alright job and as the time progresses the trend is i mean like it's kind of getting the trend but the power of these jumps are nowhere as predicted as the real prices and i mean like the predictions at least to me look uh that they get the general trend lines of the the real values and uh yeah you might think that you have a bitcoin price predictor but yeah this is not no way a financial advice so don't take this model and use it in production and basically buy or sell based on what it says i mean like it might work but do it on your own risk so this is pretty much the final result of our lstm there might it might be the case that i'm somewhere leaking some of the data but i think that this general approach to time series forecasting is very very good and these are the results that you might expect to get there you have it uh you have a model that can predict bitcoin prices i mean like it's not the perfect thing in the world but uh at least you know how you can get some time series data converted into sequences or a set of sequences how you can do some scaling of the data then convert all of this into a format for pytorch and pytorch whitening training how you can use an lstm and hopefully evaluate the results and get some some very well trained models of course you might want to twiddle or tweak the hyper parameters for example the number of hidden layers or the probably the dropout the number of layers of the ostm you might stuck at different architectures you might want to try attention in lstm and uh of course you might try whole new models all together but at the end this is a simple way of approaching time series forecasting projects thanks for watching guys please like this video subscribe to the channel and in the next one i'm going to show you how you can basically reuse this same framework for classifying uh time series data so we are going to take some input some sequence and we are going to classify the the the sequence into some uh predefined course thanks for watching bye

Up Next

Transformer from Scratch in PyTorch: Full Tutorial

@umarjamilai

344.8K views•2023-05-25

BitTorrent Protocol Explained: Piece Selection & Peer Choking

@StevenGordonAU

481 views•2013-02-22

Multivariate Time Series Preprocessing with Pandas in Python

@venelin_valkov

37.4K views•2021-03-27

Enigma Machine Mechanics: WWII Encryption Explained

@JaredOwen

13.2M views•2021-12-11

Related Study Plans & Knowledge Roadmaps

Structured learning paths in Computer Science

View All Computer Science Topics

computer-science

Building BitTorrent: Go, P2P & Concurrency

01Go Fundamentals & Concurrency

02Networking Foundations & P2P Architecture

03Bencode Parsing & Torrent Metadata

+ 3 more learning modules

Explore Roadmap

computer-science

Actor Models (C++ Concurrency & Lock-Free)

01C++ Multi-Threading Foundations

02Thread Pools and Task Scheduling

03Atomics and Lock-Free Queue Design

+ 3 more learning modules

Explore Roadmap

computer-science

Coding HM Type Inference: Algorithm W & OCaml

01Introduction to Functional Programming & OCaml

02Abstract Syntax Trees & Language Interpreters

03Type Systems & Lambda Calculus

+ 2 more learning modules

Explore Roadmap

computer-science

Building OAuth 2.0: Node.js OIDC Server

01Web & Security Foundations

02Authentication vs. Authorization & JWTs

03The OAuth 2.0 Protocol & Grant Types

+ 3 more learning modules

Explore Roadmap