Orthogonal Recurrent Neural Networks with Scaled Cayley Transform

Introduction

Deep neural networks have been used to solve numerical problems of varying complexity. RNNs have parameters that are reused at each time step of a sequential data point and have achieved state of the art performance on many sequential learning tasks. Nearly all optimization algorithms for neural networks involve some variant of gradient descent. One major obstacle to training RNNs with gradient descent is due to vanishing or exploding gradients, as described in Bengio et al. (1993) and Pascanu et al. (2013). This problem refers to the tendency of gradients to grow or decay exponentially in size, resulting in gradient descent steps that are too small to be effective or so large that the network oversteps the local minimum. This issue significantly diminishes RNNs’ ability to learn time-based dependencies, particularly in problems with long input sequences.

A variety of architectures have been introduced to overcome this difficulty. The current preferred RNN architectures are those that introduce gating mechanisms to control when information is retained or discarded, such as LSTMs (Hochreiter & Schmidhuber, 1997) and GRUs (Cho et al., 2014), at the cost of additional trainable parameters. More recently, the unitary evolution RNN (uRNN) (Arjovsky et al., 2016) uses a parametrization that forces the recurrent weight matrix to remain unitary throughout training, and exhibits superior performance to LSTMs on a variety of testing problems. For clarity, we follow the convention of Wisdom et al. (2016) and refer to this network as the restricted-capacity uRNN.

Since the introduction of uRNNs, orthogonal and unitary RNN schemes have increased in both popularity and complexity. Wisdom et al. (2016) use a multiplicative update method detailed in Tagare (2011) and Wen & Yin (2013) to expand uRNNs’ capacity to include all unitary matrices. These networks are referred to as full-capacity uRNNs. Jing et al. (2016) and Mhammedi et al. (2017) parametrize the space of unitary/orthogonal matrices with Givens rotations and Householder reflections, respectively, but typically optimize over a subset of this space by restricting the number of parameters. Another complex parametrization has also been explored in Hyland & Gunnar (2017). There is also work using unitary matrices in GRUs (i.e. in GORU of Jing et al. (2017)) or near-unitary matrices in RNNs by restricting the singular values of the recurrent matrix to an interval around $1$ (see Vorontsov et al. (2017)). For other work in addressing the vanishing and exploding gradient problem, see Henaff et al. (2017) and Le et al. (2015).

In this paper, we consider RNNs with a recurrent weight matrix taken from the set of all orthogonal matrices. To construct the orthogonal weight matrix, we parametrize it with a skew-symmetric matrix through a scaled Cayley transform. This scaling allows us to avoid the singularity issue occurring for $-1$ eigenvalues that may arise in the standard Cayley transform. By tuning this scaling matrix, the network can reach an appropriate orthogonal matrix using a relatively simple gradient descent update step. The resulting method achieves superior performance on various sequential data tasks.

The method we present in this paper works entirely with real matrices, and as such, our results deal only with orthogonal and skew-symmetric matrices. However, the method and all related theory remain valid for unitary and skew-Hermitian matrices in the complex case. The experimental results in this paper indicate that state of the art performance can be achieved without using complex matrices to optimize along the Stiefel manifold.

Background

2 Unitary RNNs

A real matrix $W$ is orthogonal if it satisfies $W^{T}W=I$. The complex analog of orthogonal matrices are unitary matrices, which satisfy $W^{*}W=I$, where $*$ denotes the conjugate transpose. Orthogonal and unitary matrices have the desirable property that $\|Wx\|_{2}=\|x\|_{2}$ for any vector $x$. This property motivates the use of orthogonal or unitary matrices in RNNs to avoid vanishing and exploding gradients, as detailed in Arjovsky et al. (2016).

Arjovsky et al. (2016) follow the framework of the previous section for their restricted-capacity uRNN, but introduce a parametrization of the recurrent matrix $W$ using a product of simpler matrices. This parameterization is given by a product consisting of diagonal matrices with complex norm $1$, complex Householder reflection matrices, discrete Fourier transform matrices, and a fixed permutation matrix with the resulting product being unitary. The Efficient Unitary RNN (EURNN) by Jing et al. (2016) and orthogonal RNN (oRNN) by Mhammedi et al. (2017) parametrize in a similar manner with products of Givens rotation matrices and Householder reflection matrices, respectively. This can also be seen in the parametrization through matrix exponentials in Hyland & Gunnar (2017), which does not appear to perform as well as the restricted-capacity uRNN.

Wisdom et al. (2016) note that this representation has only $7n$ parameters, which is insufficient to represent all unitary matrices for $n>7$. In response, they present the full-capacity uRNN, which uses a multiplicative update step that is able to reach all unitary matrices of order $n$.

Scaled Cayley Orthogonal RNN

The Cayley transform gives a representation of orthogonal matrices without $-1$ eigenvalues using skew-symmetric matrices (i.e., matrices where $A^{T}=-A$):

This bijection parametrizes the set of orthogonal matrices without $-1$ eigenvalues with skew-symmetric matrices. This direct and simple parametrization is attractive from a machine learning perspective because it is closed under addition: the sum or difference of two skew-symmetric matrices is also skew-symmetric, so we can use gradient descent algorithms like RMSprop (Tieleman & Hinton, 2012) or Adam (Kingma & Ba, 2014) to train parameters.

However, this parametrization cannot represent orthogonal matrices with $-1$ eigenvalues, since in this case $I+W$ is not invertible. Theoretically, we can still represent matrices with eigenvalues that are arbitrarily close to $-1$; however, it can require large entries of $A$. For example, a 2x2 orthogonal matrix $W$ with eigenvalues $\approx-0.99999\pm 0.00447i$ and its parametrization $A$ by the Cayley transform is given below, where $\alpha=0.99999$.

Gradient descent algorithms will learn this $A$ matrix very slowly, if at all. This difficulty can be overcome through a suitable diagonal scaling according to results from Kahan (2006).

Theorem 3.1 Every orthogonal matrix $W$ can be expressed as

where $A=[a_{ij}]$ is real-valued, skew-symmetric with $|a_{ij}|\leq 1$, and $D$ is diagonal with all nonzero entries equal to $\pm 1$.

We call the transform in Theorem 3.1 the scaled Cayley transform. Then, with an appropriate choice of $D$, the scaled Cayley transform can reach any orthogonal matrix including those with $-1$ eigenvalues. Further, it ensures that the skew-symmetric matrix $A$ that generates the orthogonal matrix will be bounded.

Our proposed network, the scaled Cayley orthogonal recurrent neural network (scoRNN), is based on this theorem. We parametrize the recurrent weight matrix $W$ through a skew-symmetric matrix $A$, which results in $\frac{n(n-1)}{2}$ trainable weights. The recurrent matrix $W$ is formed by the scaled Cayley transform: $W=(I+A)^{-1}(I-A)D$. The scoRNN then operates identically to the set of equations given in Section 2.1, but during training we update the skew-symmetric matrix $A$ using gradient descent, while $D$ is fixed throughout the training process. The number of $-1$s on the diagonal of $D$, which we call $\rho$, is considered a hyperparameter in this work and is manually chosen based on the task.

2 Update Scheme

To update the recurrent parameter matrix $A$ as described in Section 3.1, we must find the gradients of $A$ by backpropagating through the Cayley transform. The following theorem describes these gradients. A proof is given in the supplemental material.

At each training step of scoRNN, we first use the standard backpropagation algorithm to compute $\frac{\partial L}{\partial W}$ and then use Theorem 3.2 to compute $\frac{\partial L}{\partial A}$. We then update $A$ with gradient descent (or a related optimization method), and reconstruct $W$ as follows:

$\displaystyle\begin{aligned} A^{(k+1)}&=A^{(k)}-\lambda\frac{\partial L(W(A^{(k)}))}{\partial A}\\ W^{(k+1)}&=\left(I+A^{(k+1)}\right)^{-1}\left(I-A^{(k+1)}\right)D\end{aligned}$

The skew-symmetry of $\frac{\partial L}{\partial A}$ ensures that $A^{(k+1)}$ will be skew-symmetric and, in turn, $W^{(k+1)}$ will be orthogonal.

The orthogonality of the recurrent matrix is maintained to the order of machine precision, see section 5.5.1. The scoRNN also maintains stable hidden state gradients in the sense that the gradient norm does not change significantly in time, see section 5.5.2 for experimental results. This is achieved with small overhead computational costs over the standard RNN, see section 5.5.3 for experimental results concerning computational efficiency.

The scoRNN, full-capacity uRNN, EURNN, and oRNN models all have the theoretical capacity to optimize over all orthogonal or unitary recurrent matrices, but their optimization schemes are different. The full-capacity uRNN performs a multiplicative update that moves $W$ along the tangent space of the Stiefel manifold, which is shown to be a descent direction. The scoRNN, the EURNN, and the oRNN use three different representations of orthogonal matrices. The euRNN and oRNN express an orthogonal matrix as a long product of simple orthogonal matrices (Givens rotations and Householder reflections resp.) while the scoRNN uses a single rational transformation. They all use the steepest descent with respect to their corresponding parametrizations. Here, different parametrizations have different nonlinearities and hence different optimization difficulties. We note that EURNN and oRNN are usually implemented in a reduced capacity setting that uses a truncated product. In our testing, it appears that increasing capacity in EURNN and oRNN may not improve their performance.

Other Architecture Details

The modReLU function was first implemented by Arjovsky et al. (2016) to handle complex valued functions and weights. Unlike previous methods, our method only uses real-valued functions and weights. Nevertheless, we have found that the modReLU function in the real case also performed better than other activation functions. The function is defined as

where $b$ is a trainable bias. In the real case, this simplifies to $\text{sign}(z)\sigma_{\text{ReLU}}(|z|+b)$. To implement this activation function in scoRNN, we replace the computation of $h_{t}$ in Section 2.1 with

We believe that the improved performance of the modReLU over other activation functions, such as ReLU, is because it admits both positive and negative activation values, which appears to be important for the state transition in orthogonal RNNs. This is similar to the hyperbolic tangent function but does not have vanishing gradient issues.

2 Initialization

Modifying the initialization of our parameter matrices, in particular our recurrent parameter matrix $A$, had an effect on performance. The most effective initialization method we found uses a technique inspired by Henaff et al. (2017). We initialize all of the entries of $A$ to be except for 2x2 blocks along the diagonal, which are given as

with $s_{j}=\sqrt{\frac{1-\cos{(t_{j})}}{1+\cos{(t_{j})}}}$ and $t_{j}$ is sampled uniformly from $\left[0,\frac{\pi}{2}\right]$. The Cayley transform of this $A$ will have eigenvalues equal to $\pm e^{it_{j}}$ for each $j$, which will be distributed uniformly along the right unit half-circle. Multiplication by the scaling matrix $D$ will reflect $\rho$ of these eigenvalues across the imaginary axis. We use this method to initialize scoRNN’s $A$ matrix in all experiments listed in section 5.

Experiments

In the following experiments, we compare the scoRNN against LSTM and several other orthogonal and unitary RNN models. Code for these experiments is available at https://github.com/SpartinStuff/scoRNN. For each experiment, we found optimal hyperparameters for scoRNN using a grid search. For other models, we used the best hyperparameter settings as reported for the same testing problems, when applicable, or performed a grid search to find hyperparameters. For the LSTM, the forget gate bias was tuned over the integers $-4$ to $4$ with it set to 1.0 unless otherwise noted.

This experiment follows descriptions found in Jing et al. (2016), Arjovsky et al. (2016), and Wisdom et al. (2016), and tests an RNN’s ability to reproduce a sequence seen many timesteps earlier. In the problem setup, there are 10 input classes, which we denote using the digits 0-9, with 0 being used as a ’blank’ class and 9 being used as a ’marker’ class. The RNN receives an input sequence of length $T+20$. This sequence consists of entirely zeros, except for the first ten elements, which are uniformly sampled from classes 1-8, and a 9 placed ten timesteps from the end. The goal for the machine is to output zeros until it sees a 9, at which point it should output the ten elements from the beginning of the input sequence. Thus, information must propagate from the beginning to the end of the sequence for a machine to successfully learn this task, making it critical to avoid vanishing/exploding gradients.

A baseline strategy with which to compare machine performance is that of outputting 0 until the machine sees a 9, and then outputting 10 elements randomly sampled from classes 1-8. The expected cross-entropy for such a strategy is $\frac{10\log{(8)}}{T+20}$. In practice, it is common to see gated RNNs such as LSTMs converge to this local minimum.

We use hyperparameters and hidden unit sizes as reported in experiments in Arjovsky et al. (2016), Wisdom et al. (2016), and Jing et al. (2016). This results in an LSTM with $n=68$, a restricted-capacity uRNN with $n=470$, a full-capacity uRNN with $n=128$, and a tunable EURNN with $n=512$ and capacity $L=2$. As indicated in Mhammedi et al. (2017), we were unable to obtain satisfactory performance for the oRNN on this task. To match the $\approx 22k$ trainable parameters in the LSTM and uRNNs, we use a scoRNN with $n=190$. We found the best performance with the scoRNN came from $\rho=n/2$, which gives an initial $W$ with eigenvalues distributed uniformly on the unit circle.

Figure 1 compares each model’s performance for $T=1000$ and $T=2000$, with the baseline cross-entropy given as a dashed line. In both cases, cross entropy for the LSTM, restricted-capacity uRNN, and EURNN remains at the baseline or does not entirely converge over the entire experiment. For the $T=1000$ test, the full-capacity uRNN and scoRNN converge immediately to zero entropy solutions, with the full-capacity uRNN converging slightly faster. For $T=2000$, the full-capacity uRNN remains at the baseline for several thousand iterations, but is eventually able to find a correct solution. In contrast, the scoRNN error has a smooth convergence that bypasses the baseline, but does so more slowly than the full-capacity uRNN.

2 Adding Problem

We examined a variation of the adding problem as proposed by Arjovsky et al. (2016) which is based on the work of Hochreiter & Schmidhuber (1997). This variation involves passing two sequences concurrently into the RNN, each of length $T$. The first sequence is a sequence of digits sampled uniformly with values ranging in a half-open interval, $\mathcal{U}[0,1)$. The second sequence is a marker sequence consisting of all zeros except for two entries that are marked by one. The first 1 is located uniformly within the interval $[1,\frac{T}{2})$ of the sequence and the second 1 is located uniformly within the interval $[\frac{T}{2},T)$ of the sequence. The label for each pair of sequences is the sum of the two entries that are marked by one, which forces the machine to identify relevant information in the first sequence among noise. As the sequence length increases, it becomes more crucial to avoid vanishing/exploding gradients. Naively predicting one regardless of the sequence gives an expected mean squared error (MSE) of approximately 0.167. This will be considered as the baseline.

The number of hidden units for the LSTM, scoRNN and uRNNs were adjusted so that each had approximately 15k trainable parameters. This results in $n=170$ for the scoRNN, $n=60$ for the LSTM, $n=120$ for the Full-Capacity uRNN, and $n=950$ for the restricted-capacity uRNN. We tested both the tunable-style EURNN and FFT-style EURNN with $n=512$, and found better results from the tunable-style ($\approx 3$k parameters) for sequence lengths $T=200$ and $T=400$, and from the FFT-style ($\approx 7$k parameters) for sequence length $T=750$. The best hyperparameters for the oRNN were in accordance with Mhammedi et al. (2017) which was $n=128$ with 16 reflections with a learning rate of $0.01$, $\approx$2.6k parameters. We found that performance decreased when matching the number of reflections to the hidden size to increase the number of parameters.

The test set MSE results for sequence lengths $T=$ 200, $T=$ 400, and $T=$ 750 can be found in Figure 2. A training set size of 100,000 and a testing set size of 10,000 were used for each sequence length. For each case, the networks start at or near the baseline MSE, except for the EURNN for $T=750$, and drop towards zero after a few epochs. As the sequence length increases, the number of epochs before the drop increases. We found the best settings for the scoRNN were $\rho=n/2$ for $T=$ 200 and $\rho=7n/10$ for $T=$ 400 and $T=$ 750. The forget bias for the LSTM was 2 for sequence length 200, 4 for sequence length 400, and 0 for sequence length 750. As can be seen, the LSTM error drops precipitously across the board. Although the oRNN begins to drop below the baseline before scoRNN, it has a much more irregular descent curve, and jumps back to the baseline after several epochs.

3 Pixel-by-Pixel MNIST

We ran two experiments based around classifying samples from the well-known MNIST dataset (LeCun et al., ). Following the implementation of Le et al. (2015), each pixel of the image is fed into the RNN sequentially, resulting in a single pixel sequence length of 784. In the first experiment, which we refer to as unpermuted MNIST, pixels are arranged in the sequence row-by-row. In the second, which we call permuted MNIST, a fixed permutation is applied to training and testing sequences.

All scoRNN machines were trained with the RMSprop optimization algorithm. Input and output weights used a learning rate of $10^{-3}$, while the recurrent parameters used a learning rate of $10^{-4}$ (for $n=170$) or $10^{-5}$ (for $n=360$ and $n=512$). For unpermuted MNIST, we found $\rho$ to be optimal at $n/10$, while the best value of $\rho$ for permuted MNIST was $n/2$. We suspect that the difference of these two values comes from the different types of dependencies in each: unpermuted MNIST has mostly local dependencies, while permuted MNIST requires learning many long-term dependencies, which appear to be more easily modeled when the diagonal of $D$ has a higher proportion of $-1$s.

Each experiment used a training set of 55,000 images and a test set of 10,000 testing images. Each machine was trained for 70 epochs, and test set accuracy, the percentage of test images classified correctly, was evaluated at the conclusion of each epoch. Figure 3 shows test set accuracy over time, and the best performance over all epochs by each machine is given in Table 1.

In both experiments, the 170 hidden unit scoRNN gives similar performance to both of the 512 hidden unit uRNNs using a much smaller hidden dimension and, in the case of the full-capacity uRNN, an order of magnitude fewer parameters. Matching the number of parameters ($\approx 69k$), the 2170 restricted-capacity uRNN performance was comparable to the 360 hidden unit scoRNN for unpermuted MNIST, but performed worse for permuted MNIST, and required a much larger hidden size and a significantly longer run time, see 5.5.3. As in experiments presented in Arjovsky et al. (2016) and Wisdom et al. (2016), orthogonal and unitary RNNs are unable to outperform the LSTM in the unpermuted case. However, the 512 hidden unit scoRNN outperforms all other unitary RNNs. On permuted MNIST, the 512 hidden unit scoRNN achieves a test-set accuracy of 96.6%, outperforming all other machines. We believe this is a state of the art result.

4 TIMIT Speech Dataset

To see how the models performed on audio data, speech prediction was performed on the TIMIT dataset (Garofolo et al., 1993), a collection of real-world speech recordings. Excluding the dialect SA sentences and using only the core test set, the dataset consisted of 3,696 training and 192 testing audio files. Similar to experiments in Wisdom et al. (2016), audio files were downsampled to 8kHz and a short-time Fourier transform (STFT) was applied with a Hann window of 256 samples and a window hop of 128 samples (16 milliseconds). The result is a set of frames, each with 129 complex-valued Fourier amplitudes. The log-magnitude of these amplitudes is used as the input data for the machines. For each model, the hidden layer sizes were adjusted such that each model had approximately equal numbers of trainable parameters. For scoRNN, we used the Adam optimizer with learning rate $10^{-3}$ to train input and output parameters, and RMSprop with a learning rate of $10^{-3}$ (for $n=224$) or $10^{-4}$ (for $n=322,425$) to train the recurrent weight matrix. The number of negative eigenvalues used was $\rho=n/10$. The LSTM forget gate bias was initialized to -4.

The loss function used for training was the mean squared error (MSE) between the predicted and actual log-magnitudes of the next time frame over the entire sequence. Table 2 contains the MSE on validation and testing sets, which shows that all scoRNN models achieve a smaller MSE than all LSTM and unitary RNN models. Similar to Wisdom et al. (2016), we reconstructed audio files using the predicted log-magnitudes from each machine and evaluated them on several audio metrics. We found that the scoRNN predictions achieved better scores on the signal-to-noise ratio metric SegSNR (Brookes et al., 1997), but performed slightly worse than the full-capacity uRNN predictions on STOI (Taal et al., 2011) and PESQ (Rix et al., 2001), both metrics used to measure human intelligibility and perception.

5 Further Analysis

In the scoRNN architecture, the recurrent weight matrix is parameterized with a skew-symmetric matrix through the Cayley transform. This ensures the computed recurrent weight matrix in floating point arithmetic is orthogonal to the order of machine precision after each update step. Unlike scoRNN, the full-capacity uRNN maintains a unitary recurrent weight matrix by a multiplicative update scheme. Due to the accumulation of rounding errors over a large number of repeated matrix multiplications, the recurrent weight may not remain unitary throughout training. To investigate this, we ran the scoRNN and full-capacity uRNN with equal hidden unit sizes of $n=512$ on the unpermuted MNIST experiment and checked for loss of orthogonality at each epoch. The results of this experiment are shown in Figure 4. As can be seen, the recurrent weight matrix for the full-capacity uRNN becomes less unitary over time, but the orthogonality recurrent weight matrix for scoRNN is not affected by roundoff errors.

This can become particularly apparent when performing operations using a graphics processing unit (GPU) which have a much lower machine precision than a standard computer processing unit (CPU).

5.2 Vanishing Gradients

As discussed in Arjovsky et al. (2016), the vanishing/exploding gradient problem is caused by rapid growth or decay of the gradient of the hidden state $\frac{\partial L}{\partial h_{t}}$ as we move earlier in the sequence (that is, as $t$ decreases). To see if vanishing/exploding gradients affect the scoRNN model, we examined hidden state gradients in the scoRNN and LSTM models on the adding problem experiment (see section 5.2) with sequence length $T=500$.

The norms of these gradients are shown at two different points in time during training in Figure 5. As can be seen, LSTM gradient norms decrease steadily as we move away from the end of the sequence. The right half of Figure 5 shows that this vanishing effect is exacerbated by training after 300 iterations.

In contrast, scoRNN gradients decay by less than an order of magnitude at the beginning of training, remaining near $10^{-2}$ for all timesteps. Even after 300 iterations of training, scoRNN hidden state gradients decay only slightly, from $10^{-3}$ at $t=500$ to $10^{-4}$ at $t=0$. This allows information to easily propagate from beginning of the sequence to end.

5.3 Complexity and Speed

The scoRNN architecture is similar in complexity and memory usage to a standard RNN except for the additional memory requirement of storing the $n(n-1)/2$ entries of the skew-symmetric matrix $A$ and the additional complexity of forming the recurrent weight matrix $W$ from $A$ with the scaled Cayley transform. We note that the recurrent weight matrix is generated from the skew-symmetric $A$ matrix only once per training iteration; this $\mathcal{O}(n^{3})$ computational cost is comparable to one training iteration of a standard RNN, which is $\mathcal{O}(BTn^{2})$ where $T$ is the length of the sequences and $B$ is the mini-batch size, when $BT$ is comparable to $n$.

To experimentally quantify potential differences between scoRNN and other models, the real run-time for the unpermuted MNIST experiment were recorded and are included in Table 3. All models were run on the same machine, which has an Intel Core i5-7400 processor and an nVidia GeForce GTX 1080 GPU. The scoRNN and LSTM models were run in Tensorflow, while the full and restricted capacity uRNNs were run using code provided in Wisdom et al. (2016).

The RNN and LSTM models were fastest, and hidden sizes largely did not affect time taken per epoch; we suspect this is because these models were built in to Tensorflow. The LSTMs are of similar speed to the $n=170$ scoRNN, while they are approximately twice as fast as the $n=512$ scoRNN. Matching the number of hidden parameters, the scoRNN model with $n=170$ is approximately 1.5 times faster than the restricted-capacity uRNN with $n=512$, and twice as fast as the full-capacity uRNN with $n=116$. This relationship can also be seen in the scoRNN and full-capacity uRNN models with $\approx 137k$ parameters, where the scoRNN takes 11.2 minutes per epoch as compared to 25.8 minutes for the full-capacity uRNN.

Conclusion

There has been recent promising work with RNN architectures using unitary and orthogonal recurrent weight matrices to address the vanishing/exploding gradient problem. The unitary/orthogonal RNNs are typically implemented with complex valued matrices or in restricted capacity. The scoRNN developed in this paper uses real valued orthogonal recurrent weight matrices with a simpler implementation scheme, with the representational capacity to reach all orthogonal matrices through the Cayley transform parametrization. The resulting model’s additive update step with respect to this parametrization maintains the orthogonality of the recurrent weight matrix in the presence of roundoff errors. Results from our experiments show that scoRNN is among the top performers in all tests with a smooth and stable convergence curve. This superior performance is achieved, in some cases, with a smaller hidden state dimension than other models.

Acknowledgements

This research was supported in part by NSF Grants DMS-1317424 and DMS-1620082.

References

Supplemental Material: Proof of Theorem 3.2

For completeness, we restate and prove Theorem 3.2.

Proof: Let $Z:=(I+A)^{-1}(I-A)$. We consider the $(i,j)$ entry of $\frac{\partial L}{\partial A}$. Taking the derivative with respect to $A_{i,j}$ where $i\neq j$ we obtain:

Using the identity $\left(I+A\right)Z=I-A$ and taking the derivative with respect to $A_{i,j}$ to both sides we obtain:

Let $E_{i,j}$ denote the matrix whose $(i,j)$ entry is 1 with all others being 0. Since $A$ is skew-symmetric, we have $\frac{\partial A}{\partial A_{i,j}}=E_{i,j}-E_{j,i}$. Combining everything, we have:

Using the above formulation, $\frac{\partial L}{\partial A_{j,j}}=0$ and $\frac{\partial L}{\partial A_{i,j}}=-\frac{\partial L}{\partial A_{j,i}}$ so that $\frac{\partial L}{\partial A}$ is a skew-symmetric matrix. Finally, by the definition of $V$ we get the desired result. $\blacksquare$