docstr: Compare one by one embedding vs all at once using FFT gradients.
  
  Note that this won't return the exact same embedding both times because
  the grid placed over the embedding will differ when placing points one
  by one vs. when placing them at once. The min/max coords will differ,
  thus changing the overall approximation. They should be quite similar
  though.
code: def test_iris_fft_transform_equivalency_with_one_by_one(self):
      """Compare one by one embedding vs all at once using FFT gradients.
  
      Note that this won't return the exact same embedding both times because
      the grid placed over the embedding will differ when placing points one
      by one vs. when placing them at once. The min/max coords will differ,
      thus changing the overall approximation. They should be quite similar
      though.
  
      """
      x_train, x_test = train_test_split(
          self.iris.data, test_size=0.1, random_state=42
      )
  
      # Set up the initial embedding
      embedding = openTSNE.TSNE(
          early_exaggeration_iter=0,
          n_iter=50,
          neighbors="exact",
          negative_gradient_method="fft",
      ).fit(x_train)
  
      # Changing the gradients using clipping changes how the points move
      # sufficiently so that the interpolation grid is shifted. This test is
      # more reliable when we don't do gradient clipping and reduce the
      # learning rate. We increase the number of iterations so that the points
      # have time to move around
      params = dict(perplexity=5)
      # Build up an embedding by adding points one by one
      new_embedding_1 = np.vstack(
          [
              embedding.transform(np.atleast_2d(point), **params)
              for point in x_test
          ]
      )
      # Add new points altogether
      new_embedding_2 = embedding.transform(x_test, **params)
  
      # Verify that the embedding has actually been optimized
      self.assertRaises(
          AssertionError,
          np.testing.assert_almost_equal,
          embedding.prepare_partial(
              x_test, perplexity=params["perplexity"]
          ),
          new_embedding_1,
      )
  
      # Check that both methods produced the same embedding
      np.testing.assert_almost_equal(
          new_embedding_1, new_embedding_2, decimal=2
      )
  
imports: import unittest
  from functools import partial
  from scipy.spatial.distance import pdist, squareform
  import openTSNE
  import openTSNE.affinity
  import openTSNE.initialization
  import numpy
  from openTSNE.callbacks import VerifyExaggerationError
  from sklearn import datasets
  from sklearn.metrics import accuracy_score
  from sklearn.model_selection import train_test_split
  from sklearn.neighbors import KNeighborsClassifier
  from sklearn.manifold import SpectralEmbedding
label_desc: Use image node_id 8 for calling the TestTSNECorrectness obj's underlying member method code with example usage: obj.test_iris_fft_transform_equivalency_with_one_by_one() without return types