Keras LSTM layers expect input as a 3D tensor shaped as (samples, timesteps, features). This structure tells the model how many independent sequences it will train on, how many time steps each sequence contains, and how many measurements are available at each time step. Most raw datasets do not arrive in this format, so reshaping is often the first practical hurdle when building an LSTM model.
A univariate series may start as a single column of values, a multivariate dataset may be stored as rows of sensor readings, and a sequence prediction task may require sliding windows that separate input history from future targets. Each case maps differently into the same required 3D structure, and getting that mapping right is essential for avoiding shape mismatch errors in Keras.
As an Amazon Associate I earn from qualifying purchases.
The following sections show how to interpret samples, timesteps, and features for common time series layouts, reshape arrays for LSTM training, prepare input and output pairs for prediction, and verify dimensions before fitting the model.
Free tools Windows power users keep installed
One-click scans. No signup required.
Understanding the 3D Input Shape Required by Keras LSTMs
Keras LSTM layers expect input data as a 3D tensor with the shape (samples, timesteps, features). This requirement is different from the 2D arrays commonly used with dense neural networks, where data is often shaped as (samples, features). The extra dimension exists because an LSTM processes ordered sequences: it needs to know not only what values are present, but also how those values are arranged across time.
#1 Best Overall
- Language Published: English
- Binding: hardcover
- It ensures you get the best usage for a longer period
The three dimensions have distinct meanings. Samples are the independent training examples in your dataset. Timesteps are the ordered observations within each sample. Features are the variables measured at each timestep. For example, if you use the previous 10 hourly temperature readings to predict the next reading, each training sample has 10 timesteps and 1 feature. If you use temperature, humidity, and pressure at each of those 10 hours, each sample has 10 timesteps and 3 features.
| Dimension | Meaning | Example |
|---|---|---|
| Samples | Number of independent sequences passed to the model | 1,000 training windows |
| Timesteps | Number of ordered time positions in each sample | 24 hourly readings per window |
| Features | Number of variables available at each timestep | Temperature, humidity, wind speed |
In Keras, this shape is usually declared on the first recurrent layer with input_shape=(timesteps, features). The sample dimension is omitted because Keras can accept different numbers of samples during training, validation, and prediction. For instance, an LSTM configured with input_shape=(10, 1) expects each sample to contain 10 timesteps and 1 feature, but it can train on 32 samples per batch, validate on 128 samples, or predict on a single sample as long as each individual sample still has the same timestep and feature structure.
A common source of confusion is treating rows in a dataset as timesteps when they may actually need to become samples. Suppose a CSV file contains one column of 5,000 sequential sales values. Feeding it directly as a 2D array shaped (5000, 1) is not enough for an LSTM, because the model sees samples and features but no timestep axis. You must first convert the series into supervised learning windows, such as 20 past values per training example, producing an input array shaped (4980, 20, 1) if each window predicts the following value.
Recommended Free Tools
How to read an LSTM input shape
- (100, 12, 1): 100 samples, each with 12 timesteps and 1 variable per timestep.
- (500, 30, 4): 500 samples, each with 30 timesteps and 4 variables per timestep.
- (1, 60, 2): a single prediction sample containing 60 timesteps and 2 variables per timestep.
The target array does not always have the same shape as the input array. For one-step forecasting, the input may be X.shape = (samples, timesteps, features) while the target is y.shape = (samples,) or (samples, 1). For sequence-to-sequence prediction, the target may also be 3D, such as (samples, output_timesteps, output_features). Before training, inspect both X.shape and y.shape and confirm that the first dimension, the number of samples, matches between them.
Mapping Samples, Timesteps, and Features to Your Dataset
Once you know that a Keras LSTM expects input shaped as [samples, timesteps, features], the next task is mapping those three dimensions to the structure of your dataset. This mapping determines whether the model sees each training example as a meaningful sequence or as a collection of unrelated values. In practical terms, a sample is one training case, a timestep is one ordered position inside that case, and a feature is one observed variable at each timestep.
For a simple time series, imagine you have daily temperature readings and want the model to use the previous 7 days to predict the next day. One sample would be a 7-day input window. The timesteps dimension would be 7, because each sample contains 7 ordered observations. The features dimension would be 1, because there is only one measured variable: temperature. If you generate 1,000 such sliding windows, your input array should have the shape (1000, 7, 1).
For multivariate data, the timesteps still represent the ordered positions in the sequence, but the features dimension increases. Suppose each hourly observation contains temperature, humidity, and wind speed, and you use the previous 24 hours to predict future demand. Each sample contains 24 timesteps, and each timestep contains 3 features. If you create 5,000 training windows, the LSTM input should be shaped as (5000, 24, 3). The model receives each sample as a 24-step sequence, where every step has a vector of three values.
How to identify each dimension
- Samples: the number of independent training examples passed to the model. In time series problems, these are often generated by a sliding window.
- Timesteps: the number of ordered observations included in each sample. This is your lookback window or sequence length.
- Features: the number of variables measured at each timestep. A univariate series has 1 feature; a multivariate series has 2 or more.
A useful way to design the shape is to describe one training example in plain language. For example: “Each sample contains 30 minutes of sensor readings, recorded once per minute, with 4 sensor values at each minute.” That sentence maps directly to timesteps = 30 and features = 4. The samples dimension is then the total number of such windows you extract from the full dataset.
| Dataset description | Samples | Timesteps | Features | Example input shape |
|---|---|---|---|---|
| 100 sequences, each with 10 values from one variable | 100 | 10 | 1 | (100, 10, 1) |
| 2,000 windows, each covering 12 hours with 5 measurements per hour | 2000 | 12 | 5 | (2000, 12, 5) |
| 500 customer sessions, each represented by 20 ordered events with 8 attributes | 500 | 20 | 8 | (500, 20, 8) |
Be careful not to confuse rows in your original table with samples. If your raw data has one row per timestamp, those rows are usually timesteps before windowing, not final LSTM samples. After you convert the continuous series into supervised learning windows, each window becomes one sample. Similarly, columns in the original table usually become features only when they represent variables observed at the same timestep, such as price, volume, and volatility for the same date.
Before fitting the model, print and inspect the array shape with a small batch of data. Check that X.shape[1] matches the intended sequence length and X.shape[2] matches the number of variables per timestep. If these dimensions are reversed, the LSTM may still run, but it will learn from the wrong structure, such as treating features as time steps or compressing an entire sequence into a single timestep.
Rank #2
Reshaping Univariate Time Series Data
A univariate time series has one observed value at each time step, such as daily temperature, hourly sales, or monthly passenger counts. Even though there is only one variable, a Keras LSTM still expects the input array to be three-dimensional: [samples, timesteps, features]. For univariate data, features is usually 1, because each time step contains a single measurement.
Do these 3 things before closing this tab:
1Scan for outdated or missing drivers - takes under a minute2Clear out junk files and repair common Windows errors3Fix the driver behind crashes, sound loss and screen glitchesSuppose you have a raw sequence of 10 observations:
[10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
If you want the model to look back over 3 time steps to predict the next value, you first convert the sequence into supervised learning samples. Each input sample contains 3 consecutive observations, and each target is the following observation:
| Input sequence | Target |
|---|---|
| [10, 20, 30] | 40 |
| [20, 30, 40] | 50 |
| [30, 40, 50] | 60 |
| [40, 50, 60] | 70 |
At this point, the input data might naturally have the shape [samples, timesteps]. For example, if there are 7 training examples and each example contains 3 past values, the array shape is (7, 3). Before passing it to an LSTM, reshape it to (7, 3, 1), where the final dimension represents the single feature at each time step.
In NumPy, this is commonly done with reshape():
X = X.reshape((X.shape[0], X.shape[1], 1))
Here, X.shape[0] is the number of samples, X.shape[1] is the number of time steps in each sample, and 1 is the number of features. The target array y usually remains two-dimensional or one-dimensional, depending on the model output. For a simple next-step forecast, y may have shape (samples,) or (samples, 1).
The Tool Desk
Outbyte PC Repair FREEClear out junk files and repair common Windows errorsFree Scan →Outbyte Driver Updater FREEFix the driver behind crashes, sound loss and screen glitchesFind Drivers →Example: single-step forecasting
For a sequence such as monthly sales, a typical setup might use the previous 12 months to predict the next month. If the transformed dataset has 988 samples, the LSTM input shape should be:
- samples: 988 training windows
- timesteps: 12 months per input window
- features: 1 sales value per month
The resulting shape is (988, 12, 1). In the Keras model, the LSTM layer should receive input_shape=(12, 1), excluding the sample dimension because Keras infers it during training.
Example: one time step with one feature
Sometimes beginners reshape a univariate series as (samples, 1, 1), meaning each training sample contains only one time step and one feature. This is valid, but it gives the LSTM no historical window to learn from within each sample. It may be suitable when the sequence dependency is handled elsewhere, but for most forecasting tasks, a longer lookback window such as (samples, 7, 1), (samples, 30, 1), or (samples, 60, 1) is more useful.
Before fitting the model, print both the input and target shapes. For example, X.shape should show three dimensions, while y.shape should align with the number of samples. If X has 500 samples, y must also have 500 target values. Many LSTM shape problems come from accidentally reshaping the original raw series directly instead of first creating sliding windows, which can produce arrays with the right number of dimensions but the wrong learning structure.
Windows Errors? Fix Them Before They Spread
Repair common Windows errors and clear accumulated junk for a smoother, more stable PC - no reinstall needed.Free scan · no reinstallOutdated Drivers Are Slowing You Down
One free scan finds every outdated or missing driver and matches the right update for your exact hardware.Free scan · exact hardware matchReshaping Multivariate Time Series Data
Multivariate time series data contains more than one observed variable at each time step. In Keras LSTM terms, those variables become the features dimension of the input tensor. The required shape is still [samples, timesteps, features], but instead of features=1 as in a univariate series, you use one feature for each measurement collected at the same point in time.
Rank #3
For example, suppose you are modeling hourly energy demand using temperature, humidity, wind speed, and previous demand. If you use the last 24 hours to predict the next value, then each training example contains 24 timesteps and 4 features per timestep. The input array should therefore have the shape [samples, 24, 4]. Each sample is a sliding window over the original table, each timestep is one hour inside that window, and each feature is one column from the dataset.
Example: converting a 2D table into 3D LSTM input
A common starting point is a 2D NumPy array or pandas DataFrame shaped like [rows, columns], where rows are ordered by time and columns are variables. If the raw array has shape [1000, 4], that means there are 1000 time points and 4 variables. To train an LSTM on windows of 24 time steps, you need to create overlapping sequences from this table rather than simply calling reshape(1000, 24, 4).
The correct transformation is to build one sample at a time. The first sample may contain rows 0 through 23, the second sample rows 1 through 24, the third rows 2 through 25, and so on. If the target is the demand value at the next hour, then the first target might come from row 24, the second from row 25, and so forth. With 1000 rows and a 24-step input window, this produces approximately 976 samples, depending on how the target horizon is defined.
| Dataset part | Example meaning | LSTM dimension |
|---|---|---|
| One sliding window | 24 consecutive hourly rows | Timesteps |
| One row inside the window | Temperature, humidity, wind speed, demand | Features |
| All generated windows | Many overlapping training examples | Samples |
Practical NumPy-style reshaping pattern
For multivariate data, the safest approach is to construct arrays explicitly so the feature columns stay aligned with their original timestamps. Conceptually, the process looks like this: choose the input columns, choose the target column, set a window length, then append each window to X and the corresponding future value to y. After conversion to arrays, X.shape should be something like (976, 24, 4), while y.shape might be (976,) for a single-output forecast or (976, 1) if you keep the target as a 2D array.
- Samples: the number of generated windows after applying the lookback period and forecast horizon.
- Timesteps: the number of historical rows included in each input window.
- Features: the number of variables available at every timestep in the window.
Be careful when using reshape() directly on a multivariate table. It only rearranges existing values according to array memory order; it does not understand time windows. Direct reshaping is appropriate only when the data is already organized as complete sequences. For instance, if you already have 500 independent sequences, each with 10 timesteps and 6 variables, a flat array of shape [500, 60] can be reshaped to [500, 10, 6] if the columns are ordered by timestep and feature consistently.
Before fitting the model, validate the result by printing X.shape, inspecting X[0], and checking that the first target value truly occurs after the first input window. Also confirm that scaling is applied consistently across feature columns. In most forecasting workflows, you fit the scaler on the training portion only, transform train and test with the same scaler, and then create or preserve the 3D structure expected by the LSTM layer.
Preparing Input and Output Arrays for Sequence Prediction
Sequence prediction usually means converting a continuous series into many supervised learning examples. Each input sample contains a window of past observations, and each output sample contains the value or sequence the model should predict next. In Keras, the input array X must be 3D with the shape (samples, timesteps, features), while the target array y depends on the prediction task: one-step forecasting, multi-step forecasting, or sequence-to-sequence prediction.
For one-step forecasting, each input window maps to a single future value. Suppose a univariate series contains daily values and you want to use the previous 5 days to predict the next day. If the raw values are [10, 12, 13, 15, 18, 20, 21, 25], the first training sample uses [10, 12, 13, 15, 18] as input and 20 as the target. The next sample uses [12, 13, 15, 18, 20] and predicts 21. After building these windows, X should be reshaped to (number_of_windows, 5, 1), because there are 5 timesteps and 1 feature per timestep. The matching y array is commonly shaped as (number_of_windows, 1) or (number_of_windows,), depending on the final Dense layer and loss function.
Common target shapes by prediction type
| Prediction task | Input X shape | Target y shape | Typical final layer |
|---|---|---|---|
| One-step univariate forecast | (samples, timesteps, 1) | (samples, 1) | Dense(1) |
| One-step multivariate forecast | (samples, timesteps, features) | (samples, 1) or (samples, target_features) | Dense(1) or Dense(target_features) |
| Multi-step forecast | (samples, timesteps, features) | (samples, forecast_horizon) | Dense(forecast_horizon) |
| Sequence-to-sequence forecast | (samples, timesteps, features) | (samples, output_timesteps, output_features) | LSTM(…, return_sequences=True) plus TimeDistributed(Dense(…)) |
For multivariate sequence prediction, the same windowing idea applies, but each timestep contains mulle feature values. For example, if each hourly record has temperature, humidity, and pressure, and the model uses the previous 24 hours to predict the next temperature value, each input sample has shape (24, 3). After stacking all samples, X becomes (samples, 24, 3). The target y might contain only the next temperature value, shaped as (samples, 1), even though the input includes three features. If the model predicts the next temperature, humidity, and pressure together, then y should be shaped as (samples, 3).
Multi-step forecasting changes the output array because each sample predicts more than one future timestep. If you use 24 past hours to predict the next 6 hours of demand, X has shape (samples, 24, features) and y can have shape (samples, 6) for a single target variable. If predicting mulle variables across those 6 future timesteps, y is often clearer as (samples, 6, target_features). This 3D target format is especially useful when the model is designed to return a sequence rather than a single vector.
Rank #4
- Check alignment: the first target should occur immediately after the last timestep in the corresponding input window, unless you intentionally use a prediction gap.
- Check sample counts: X.shape[0] and y.shape[0] must match exactly.
- Check feature placement: features belong on axis 2 of X, not mixed into the timestep axis.
- Check output design: match the shape of y to the model’s final layer output, such as Dense(1), Dense(6), or a sequence-returning layer stack.
Handling Stateful LSTMs and Batch Size Requirements
A stateful LSTM in Keras keeps its hidden state from one batch and uses it as the starting state for the next batch. This is different from the default stateless behavior, where the state is reset after each batch. Stateful training can be useful when a long time series has been split into shorter windows but you still want the model to carry temporal context forward across those windows.
Statefulness adds one strict requirement: the batch size must be fixed and consistent. For a stateful LSTM, Keras needs to know which sample in the current batch follows which sample in the previous batch. That means sample 0 in batch 2 is treated as the continuation of sample 0 in batch 1, sample 1 follows sample 1, and so on. Because of this alignment, you should not shuffle training data when using a stateful LSTM.
Defining a fixed batch size
With stateless LSTMs, the input shape usually excludes the batch dimension, such as (timesteps, features). With stateful LSTMs, you define the batch dimension explicitly. In modern Keras, this is commonly done with an input layer that specifies batch_shape, for example (batch_size, timesteps, features).
For example, if each training sample contains 20 timesteps and 3 features, and you want to train with batches of 16 samples, the input shape is fixed as (16, 20, 3). Your array still needs to be a 3D tensor with the structure [samples, timesteps, features], but the total number of samples should be divisible by 16 unless you deliberately drop or pad the remainder.
- Samples: total number of training windows, such as 1600.
- Timesteps: number of observations per window, such as 20.
- Features: number of variables at each timestep, such as 3.
- Batch size: fixed number of samples processed together, such as 16.
Preparing data for stateful training
Suppose you have an input array shaped (1003, 20, 3) and want to use batch_size=16. Since 1003 is not divisible by 16, the final partial batch has only 11 samples. A stateful LSTM cannot use changing batch sizes across batches, so you should trim the data to 992 samples, pad it to 1008, or configure your dataset pipeline to drop the remainder. The corresponding target array must be trimmed or padded in exactly the same way.
Quick wins for a faster PC:
Clear out junk files and repair common Windows errorsFree Scan →Scan for outdated or missing drivers - takes under a minuteDriver Scan →Repair Windows errors before they cause bigger problemsFix Now →| Use case | Input shape | Batch requirement |
|---|---|---|
| Univariate stateful forecasting | (samples, timesteps, 1) |
samples % batch_size == 0 |
| Multivariate stateful forecasting | (samples, timesteps, features) |
Same fixed batch size for every batch |
| Sequence-to-sequence prediction | (samples, timesteps, features) |
Targets must preserve matching sample order |
You also need to control when the model state is reset. If each epoch represents a continuous pass over the same ordered sequence, you may reset states at the end of each epoch. If each training segment represents a separate series, reset states between segments so the model does not carry information from one independent sequence into another. In Keras, this is commonly handled by calling model.reset_states() at the appropriate boundary.
Validation and prediction with stateful models
The same fixed batch size applies during validation and prediction. If you train with batch_size=16, validation inputs must also be supplied in batches of 16 unless you build a separate inference model with the same weights but a different batch size. This often surprises users when prediction fails on a single sample shaped (1, timesteps, features) after training a stateful model with a larger fixed batch size.
Before fitting, print and check both arrays: X.shape should be (samples, timesteps, features), y.shape should have the same number of samples, and samples should divide cleanly by the chosen batch size. During training, use shuffle=False so batch order remains meaningful. These checks prevent many stateful LSTM errors that appear to be reshaping problems but are actually caused by changing batch sizes or misaligned sample order.
Common Shape Errors and How to Debug Them
Most Keras LSTM shape problems come from giving the layer a 2D array when it expects a 3D tensor, or from mixing up the order of samples, timesteps, and features. An LSTM input should normally have the form (samples, timesteps, features). For example, 1,000 sliding windows, each containing 24 hourly observations of 3 variables, should be shaped as (1000, 24, 3). If the array is instead shaped as (1000, 72), Keras sees only two dimensions and cannot infer the temporal structure.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Frequent error messages
- Expected ndim=3, found ndim=2: The model received a flat matrix such as (samples, columns). Reshape it to include timesteps and features.
- Input 0 is incompatible with layer: The shape passed to the model does not match the input_shape declared in the first LSTM layer.
- Data cardinality is ambiguous: The number of samples in X and y does not match. Check the first dimension of both arrays.
- Cannot reshape array of size … into shape …: The requested reshape does not preserve the total number of values. The product of the dimensions must remain unchanged.
- Incompatible shapes during training: The target array shape does not match the output produced by the model, often in sequence-to-sequence setups.
A reliable debugging pattern is to print shapes at every stage: after loading, after scaling, after creating windows, after train-test splitting, and immediately before calling model.fit(). For a univariate one-step forecasting task, a valid input might be X.shape == (500, 12, 1) and y.shape == (500,) or (500, 1). For a multivariate task using 5 variables over 12 timesteps, a valid input might be (500, 12, 5). If the model predicts one value per sample, the target may still be (500, 1); if it predicts a 6-step future sequence, the target might be (500, 6) or (500, 6, 1), depending on the final layers.
Best Value
| Use case | Expected X shape | Typical y shape |
|---|---|---|
| Univariate one-step forecast | (samples, timesteps, 1) | (samples, 1) |
| Multivariate one-step forecast | (samples, timesteps, features) | (samples, 1) |
| Multi-step forecast | (samples, input_timesteps, features) | (samples, output_timesteps) |
| Sequence-to-sequence forecast | (samples, input_timesteps, features) | (samples, output_timesteps, target_features) |
Be careful when using pandas, because selecting a single column can produce a Series instead of a 2D DataFrame. For example, selecting df[“sales”] gives a 1D structure, while df[[“sales”]] keeps a 2D structure that is easier to window and reshape. Also check scaling steps: many scalers expect 2D input, so you may need to scale data before converting it into 3D windows, or temporarily flatten and restore the LSTM shape afterward.
For stateful LSTMs, verify that the number of samples is divisible by the fixed batch size, because Keras must maintain state across consistent batch positions. If batch_size=32, then 513 samples will cause problems unless you trim, pad, or choose a compatible batch size. A practical final check before training is to compare X.shape[0] with y.shape[0], confirm that X.ndim == 3, confirm that X.shape[1] equals the intended window length, and confirm that X.shape[2] equals the number of input variables.
Frequently Asked Questions
What shape does a Keras LSTM layer expect for input data?
Keras LSTM layers expect input as a 3D tensor with the shape (samples, timesteps, features). For example, if you have 1,000 training windows, each containing 10 time steps and 3 variables per step, your input shape should be (1000, 10, 3). In the model definition, you usually specify only input_shape=(timesteps, features) because Keras infers the number of samples.
How do I reshape a univariate time series for an LSTM in Keras?
For a univariate series, each time step has one feature, so the last dimension should be 1. If your data is shaped like (samples, timesteps), reshape it to (samples, timesteps, 1) before passing it to the LSTM. For example, an array with shape (500, 20) should become (500, 20, 1).
How should multivariate time series data be shaped for an LSTM?
For multivariate data, the features dimension is the number of variables measured at each time step. If you have 2,000 samples, 30 time steps per sample, and 5 variables per time step, your input array should be shaped as (2000, 30, 5). Make sure the features are aligned by time step, not flattened across the sequence.
What is the difference between samples, timesteps, and features?
Samples are the independent training examples or windows you feed into the model. Timesteps are the ordered observations inside each sample, and features are the measured variables at each timestep. For example, using the past 24 hourly readings of temperature and humidity to predict the next value gives you 24 timesteps and 2 features.
How do I fix the Keras error about expected ndim=3 but found ndim=2?
This error means your LSTM received a 2D array, often shaped like (samples, timesteps), when it expected a 3D array. Add the missing features dimension, such as reshaping from (1000, 12) to (1000, 12, 1) for a univariate sequence. Print X.shape before training and confirm it matches (samples, timesteps, features).
Bottom Line
Keras LSTM layers expect input as a 3D tensor shaped (samples, timesteps, features), and most reshaping work comes down to deciding what each of those dimensions means for your problem. Whether you are working with a single time series, mulle variables, or supervised sequence windows, build your arrays so each sample contains an ordered sequence of timesteps with the correct feature values at each step.
Before training, print your array shapes, verify that inputs and targets align, and test a small batch through the model to catch shape errors early. Once the data structure matches the LSTM’s expectations, you can focus on improving window size, feature engineering, and model performance.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
