Automated rollback of change 152332221

Change: 152333917

20 files changed, 8 insertions, 1593 deletions

diff --git a/tensorflow/core/BUILD b/tensorflow/core/BUILD
index 6b7e297c4f..ba761cd7c6 100644
--- a/tensorflow/core/BUILD
+++ b/tensorflow/core/BUILD
@@ -494,6 +494,7 @@ cc_library(
 tf_gen_op_libs(
     op_lib_names = [
         "array_ops",
+        "audio_ops",
         "candidate_sampling_ops",
         "control_flow_ops",
         "ctc_ops",
@@ -523,13 +524,6 @@ tf_gen_op_libs(
     ],
 )
 
-tf_gen_op_libs(
-    op_lib_names = [
-        "audio_ops",
-    ],
-    deps = [":lib"],
-)
-
 cc_library(
     name = "debug_ops_op_lib",
     srcs = ["ops/debug_ops.cc"],
@@ -692,7 +686,6 @@ cc_library(
     visibility = ["//visibility:public"],
     deps = [
         "//tensorflow/core/kernels:array",
-        "//tensorflow/core/kernels:audio",
         "//tensorflow/core/kernels:bincount_op",
         "//tensorflow/core/kernels:candidate_sampler_ops",
         "//tensorflow/core/kernels:control_flow_ops",
diff --git a/tensorflow/core/kernels/BUILD b/tensorflow/core/kernels/BUILD
index 0a4fd0f256..9c47d520d9 100644
--- a/tensorflow/core/kernels/BUILD
+++ b/tensorflow/core/kernels/BUILD
@@ -3537,117 +3537,6 @@ tf_kernel_library(
     ],
 )
 
-filegroup(
-    name = "spectrogram_test_data",
-    srcs = [
-        "spectrogram_test_data/short_test_segment.wav",
-        "spectrogram_test_data/short_test_segment_spectrogram.csv.bin",
-        "spectrogram_test_data/short_test_segment_spectrogram_400_200.csv.bin",
-    ],
-    visibility = ["//visibility:public"],
-)
-
-cc_library(
-    name = "spectrogram",
-    srcs = ["spectrogram.cc"],
-    hdrs = ["spectrogram.h"],
-    copts = tf_copts(),
-    deps = [
-        "//tensorflow/core:framework",
-        "//tensorflow/core:lib",
-        "//third_party/fft2d:fft2d_headers",
-        "@fft2d//:fft2d",
-    ],
-)
-
-cc_library(
-    name = "spectrogram_test_utils",
-    testonly = 1,
-    srcs = ["spectrogram_test_utils.cc"],
-    hdrs = ["spectrogram_test_utils.h"],
-    copts = tf_copts(),
-    deps = [
-        "//tensorflow/core:framework",
-        "//tensorflow/core:lib",
-        "//tensorflow/core:lib_internal",
-        "//tensorflow/core:protos_all_cc",
-        "//tensorflow/core:test",
-    ],
-)
-
-cc_binary(
-    name = "spectrogram_convert_test_data",
-    testonly = 1,
-    srcs = ["spectrogram_convert_test_data.cc"],
-    deps = [
-        ":spectrogram_test_utils",
-        "//tensorflow/core:lib",
-        "//tensorflow/core:lib_internal",
-    ],
-)
-
-tf_cc_test(
-    name = "spectrogram_test",
-    size = "medium",
-    srcs = ["spectrogram_test.cc"],
-    data = [":spectrogram_test_data"],
-    deps = [
-        ":spectrogram",
-        ":spectrogram_test_utils",
-        "//tensorflow/core:lib",
-        "//tensorflow/core:lib_internal",
-        "//tensorflow/core:lib_test_internal",
-        "//tensorflow/core:protos_all_cc",
-        "//tensorflow/core:test",
-        "//tensorflow/core:test_main",
-        "//third_party/eigen3",
-    ],
-)
-
-tf_kernel_library(
-    name = "spectrogram_op",
-    prefix = "spectrogram_op",
-    deps = [
-        ":spectrogram",
-        "//tensorflow/core:audio_ops_op_lib",
-        "//tensorflow/core:core_cpu",
-        "//tensorflow/core:framework",
-        "//tensorflow/core:lib",
-        "//tensorflow/core:lib_internal",
-    ],
-    alwayslink = 1,
-)
-
-tf_cuda_cc_test(
-    name = "spectrogram_op_test",
-    size = "small",
-    srcs = ["spectrogram_op_test.cc"],
-    deps = [
-        ":ops_util",
-        ":spectrogram_op",
-        "//tensorflow/cc:cc_ops",
-        "//tensorflow/cc:client_session",
-        "//tensorflow/core:core_cpu",
-        "//tensorflow/core:framework",
-        "//tensorflow/core:framework_internal",
-        "//tensorflow/core:lib",
-        "//tensorflow/core:protos_all_cc",
-        "//tensorflow/core:tensorflow",
-        "//tensorflow/core:test",
-        "//tensorflow/core:test_main",
-        "//tensorflow/core:testlib",
-    ],
-)
-
-cc_library(
-    name = "audio",
-    deps = [
-        ":decode_wav_op",
-        ":encode_wav_op",
-        ":spectrogram_op",
-    ],
-)
-
 # Android libraries -----------------------------------------------------------
 
 # Changes to the Android srcs here should be replicated in
diff --git a/tensorflow/core/kernels/spectrogram.cc b/tensorflow/core/kernels/spectrogram.cc
deleted file mode 100644
index 7531d5d64a..0000000000
--- a/tensorflow/core/kernels/spectrogram.cc
+++ /dev/null
@@ -1,212 +0,0 @@
-/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-==============================================================================*/
-
-#include "tensorflow/core/kernels/spectrogram.h"
-
-#include <math.h>
-
-#include "third_party/fft2d/fft.h"
-#include "tensorflow/core/lib/core/bits.h"
-
-namespace tensorflow {
-
-using std::complex;
-
-namespace {
-// Returns the default Hann window function for the spectrogram.
-void GetPeriodicHann(int window_length, std::vector<double>* window) {
-  // Some platforms don't have M_PI, so define a local constant here.
-  const double pi = std::atan(1) * 4;
-  window->resize(window_length);
-  for (int i = 0; i < window_length; ++i) {
-    (*window)[i] = 0.5 - 0.5 * cos((2 * pi * i) / window_length);
-  }
-}
-}  // namespace
-
-bool Spectrogram::Initialize(int window_length, int step_length) {
-  std::vector<double> window;
-  GetPeriodicHann(window_length, &window);
-  return Initialize(window, step_length);
-}
-
-bool Spectrogram::Initialize(const std::vector<double>& window,
-                             int step_length) {
-  window_length_ = window.size();
-  window_ = window;  // Copy window.
-  if (window_length_ < 2) {
-    LOG(ERROR) << "Window length too short.";
-    initialized_ = false;
-    return false;
-  }
-
-  step_length_ = step_length;
-  if (step_length_ < 1) {
-    LOG(ERROR) << "Step length must be positive.";
-    initialized_ = false;
-    return false;
-  }
-
-  fft_length_ = NextPowerOfTwo(window_length_);
-  CHECK(fft_length_ >= window_length_);
-  output_frequency_channels_ = 1 + fft_length_ / 2;
-
-  // Allocate 2 more than what rdft needs, so we can rationalize the layout.
-  fft_input_output_.assign(fft_length_ + 2, 0.0);
-
-  int half_fft_length = fft_length_ / 2;
-  fft_double_working_area_.assign(half_fft_length, 0.0);
-  fft_integer_working_area_.assign(2 + static_cast<int>(sqrt(half_fft_length)),
-                                   0);
-  // Set flag element to ensure that the working areas are initialized
-  // on the first call to cdft.  It's redundant given the assign above,
-  // but keep it as a reminder.
-  fft_integer_working_area_[0] = 0;
-  input_queue_.clear();
-  samples_to_next_step_ = window_length_;
-  initialized_ = true;
-  return true;
-}
-
-template <class InputSample, class OutputSample>
-bool Spectrogram::ComputeComplexSpectrogram(
-    const std::vector<InputSample>& input,
-    std::vector<std::vector<complex<OutputSample>>>* output) {
-  if (!initialized_) {
-    LOG(ERROR) << "ComputeComplexSpectrogram() called before successful call "
-               << "to Initialize().";
-    return false;
-  }
-  CHECK(output);
-  output->clear();
-  int input_start = 0;
-  while (GetNextWindowOfSamples(input, &input_start)) {
-    DCHECK_EQ(input_queue_.size(), window_length_);
-    ProcessCoreFFT();  // Processes input_queue_ to fft_input_output_.
-    // Add a new slice vector onto the output, to save new result to.
-    output->resize(output->size() + 1);
-    // Get a reference to the newly added slice to fill in.
-    auto& spectrogram_slice = output->back();
-    spectrogram_slice.resize(output_frequency_channels_);
-    for (int i = 0; i < output_frequency_channels_; ++i) {
-      // This will convert double to float if it needs to.
-      spectrogram_slice[i] = complex<OutputSample>(
-          fft_input_output_[2 * i], fft_input_output_[2 * i + 1]);
-    }
-  }
-  return true;
-}
-// Instantiate it four ways:
-template bool Spectrogram::ComputeComplexSpectrogram(
-    const std::vector<float>& input, std::vector<std::vector<complex<float>>>*);
-template bool Spectrogram::ComputeComplexSpectrogram(
-    const std::vector<double>& input,
-    std::vector<std::vector<complex<float>>>*);
-template bool Spectrogram::ComputeComplexSpectrogram(
-    const std::vector<float>& input,
-    std::vector<std::vector<complex<double>>>*);
-template bool Spectrogram::ComputeComplexSpectrogram(
-    const std::vector<double>& input,
-    std::vector<std::vector<complex<double>>>*);
-
-template <class InputSample, class OutputSample>
-bool Spectrogram::ComputeSquaredMagnitudeSpectrogram(
-    const std::vector<InputSample>& input,
-    std::vector<std::vector<OutputSample>>* output) {
-  if (!initialized_) {
-    LOG(ERROR) << "ComputeSquaredMagnitudeSpectrogram() called before "
-               << "successful call to Initialize().";
-    return false;
-  }
-  CHECK(output);
-  output->clear();
-  int input_start = 0;
-  while (GetNextWindowOfSamples(input, &input_start)) {
-    DCHECK_EQ(input_queue_.size(), window_length_);
-    ProcessCoreFFT();  // Processes input_queue_ to fft_input_output_.
-    // Add a new slice vector onto the output, to save new result to.
-    output->resize(output->size() + 1);
-    // Get a reference to the newly added slice to fill in.
-    auto& spectrogram_slice = output->back();
-    spectrogram_slice.resize(output_frequency_channels_);
-    for (int i = 0; i < output_frequency_channels_; ++i) {
-      // Similar to the Complex case, except storing the norm.
-      // But the norm function is known to be a performance killer,
-      // so do it this way with explicit real and imagninary temps.
-      const double re = fft_input_output_[2 * i];
-      const double im = fft_input_output_[2 * i + 1];
-      // Which finally converts double to float if it needs to.
-      spectrogram_slice[i] = re * re + im * im;
-    }
-  }
-  return true;
-}
-// Instantiate it four ways:
-template bool Spectrogram::ComputeSquaredMagnitudeSpectrogram(
-    const std::vector<float>& input, std::vector<std::vector<float>>*);
-template bool Spectrogram::ComputeSquaredMagnitudeSpectrogram(
-    const std::vector<double>& input, std::vector<std::vector<float>>*);
-template bool Spectrogram::ComputeSquaredMagnitudeSpectrogram(
-    const std::vector<float>& input, std::vector<std::vector<double>>*);
-template bool Spectrogram::ComputeSquaredMagnitudeSpectrogram(
-    const std::vector<double>& input, std::vector<std::vector<double>>*);
-
-// Return true if a full window of samples is prepared; manage the queue.
-template <class InputSample>
-bool Spectrogram::GetNextWindowOfSamples(const std::vector<InputSample>& input,
-                                         int* input_start) {
-  auto input_it = input.begin() + *input_start;
-  int input_remaining = input.end() - input_it;
-  if (samples_to_next_step_ > input_remaining) {
-    // Copy in as many samples are left and return false, no full window.
-    input_queue_.insert(input_queue_.end(), input_it, input.end());
-    *input_start += input_remaining;  // Increases it to input.size().
-    samples_to_next_step_ -= input_remaining;
-    return false;  // Not enough for a full window.
-  } else {
-    // Copy just enough into queue to make a new window, then trim the
-    // front off the queue to make it window-sized.
-    input_queue_.insert(input_queue_.end(), input_it,
-                        input_it + samples_to_next_step_);
-    *input_start += samples_to_next_step_;
-    input_queue_.erase(
-        input_queue_.begin(),
-        input_queue_.begin() + input_queue_.size() - window_length_);
-    DCHECK_EQ(window_length_, input_queue_.size());
-    samples_to_next_step_ = step_length_;  // Be ready for next time.
-    return true;  // Yes, input_queue_ now contains exactly a window-full.
-  }
-}
-
-void Spectrogram::ProcessCoreFFT() {
-  for (int j = 0; j < window_length_; ++j) {
-    fft_input_output_[j] = input_queue_[j] * window_[j];
-  }
-  // Zero-pad the rest of the input buffer.
-  for (int j = window_length_; j < fft_length_; ++j) {
-    fft_input_output_[j] = 0.0;
-  }
-  const int kForwardFFT = 1;  // 1 means forward; -1 reverse.
-  // This real FFT is a fair amount faster than using cdft here.
-  rdft(fft_length_, kForwardFFT, &fft_input_output_[0],
-       &fft_integer_working_area_[0], &fft_double_working_area_[0]);
-  // Make rdft result look like cdft result;
-  // unpack the last real value from the first position's imag slot.
-  fft_input_output_[fft_length_] = fft_input_output_[1];
-  fft_input_output_[fft_length_ + 1] = 0;
-  fft_input_output_[1] = 0;
-}
-
-}  // namespace tensorflow
diff --git a/tensorflow/core/kernels/spectrogram.h b/tensorflow/core/kernels/spectrogram.h
deleted file mode 100644
index 5476a0a961..0000000000
--- a/tensorflow/core/kernels/spectrogram.h
+++ /dev/null
@@ -1,112 +0,0 @@
-/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-==============================================================================*/
-
-// Class for generating spectrogram slices from a waveform.
-// Initialize() should be called before calls to other functions.  Once
-// Initialize() has been called and returned true, The Compute*() functions can
-// be called repeatedly with sequential input data (ie. the first element of the
-// next input vector directly follows the last element of the previous input
-// vector). Whenever enough audio samples are buffered to produce a
-// new frame, it will be placed in output. Output is cleared on each
-// call to Compute*(). This class is thread-unsafe, and should only be
-// called from one thread at a time.
-// With the default parameters, the output of this class should be very
-// close to the results of the following MATLAB code:
-// overlap_samples = window_length_samples - step_samples;
-// window = hann(window_length_samples, 'periodic');
-// S = abs(spectrogram(audio, window, overlap_samples)).^2;
-
-#ifndef THIRD_PARTY_TENSORFLOW_CORE_KERNELS_SPECTROGRAM_H_
-#define THIRD_PARTY_TENSORFLOW_CORE_KERNELS_SPECTROGRAM_H_
-
-#include <complex>
-#include <deque>
-#include <vector>
-
-#include "third_party/fft2d/fft.h"
-#include "tensorflow/core/framework/op_kernel.h"
-#include "tensorflow/core/framework/tensor.h"
-
-namespace tensorflow {
-
-class Spectrogram {
- public:
-  Spectrogram() : initialized_(false) {}
-  ~Spectrogram() {}
-
-  // Initializes the class with a given window length and step length
-  // (both in samples). Internally a Hann window is used as the window
-  // function. Returns true on success, after which calls to Process()
-  // are possible. window_length must be greater than 1 and step
-  // length must be greater than 0.
-  bool Initialize(int window_length, int step_length);
-
-  // Initialize with an explicit window instead of a length.
-  bool Initialize(const std::vector<double>& window, int step_length);
-
-  // Processes an arbitrary amount of audio data (contained in input)
-  // to yield complex spectrogram frames. After a successful call to
-  // Initialize(), Process() may be called repeatedly with new input data
-  // each time.  The audio input is buffered internally, and the output
-  // vector is populated with as many temporally-ordered spectral slices
-  // as it is possible to generate from the input.  The output is cleared
-  // on each call before the new frames (if any) are added.
-  //
-  // The template parameters can be float or double.
-  template <class InputSample, class OutputSample>
-  bool ComputeComplexSpectrogram(
-      const std::vector<InputSample>& input,
-      std::vector<std::vector<std::complex<OutputSample>>>* output);
-
-  // This function works as the one above, but returns the power
-  // (the L2 norm, or the squared magnitude) of each complex value.
-  template <class InputSample, class OutputSample>
-  bool ComputeSquaredMagnitudeSpectrogram(
-      const std::vector<InputSample>& input,
-      std::vector<std::vector<OutputSample>>* output);
-
-  // Return reference to the window function used internally.
-  const std::vector<double>& GetWindow() const { return window_; }
-
-  // Return the number of frequency channels in the spectrogram.
-  int output_frequency_channels() const { return output_frequency_channels_; }
-
- private:
-  template <class InputSample>
-  bool GetNextWindowOfSamples(const std::vector<InputSample>& input,
-                              int* input_start);
-  void ProcessCoreFFT();
-
-  int fft_length_;
-  int output_frequency_channels_;
-  int window_length_;
-  int step_length_;
-  bool initialized_;
-  int samples_to_next_step_;
-
-  std::vector<double> window_;
-  std::vector<double> fft_input_output_;
-  std::deque<double> input_queue_;
-
-  // Working data areas for the FFT routines.
-  std::vector<int> fft_integer_working_area_;
-  std::vector<double> fft_double_working_area_;
-
-  TF_DISALLOW_COPY_AND_ASSIGN(Spectrogram);
-};
-
-}  // namespace tensorflow
-
-#endif  // THIRD_PARTY_TENSORFLOW_CORE_KERNELS_SPECTROGRAM_H_
diff --git a/tensorflow/core/kernels/spectrogram_convert_test_data.cc b/tensorflow/core/kernels/spectrogram_convert_test_data.cc
deleted file mode 100644
index bae13c0213..0000000000
--- a/tensorflow/core/kernels/spectrogram_convert_test_data.cc
+++ /dev/null
@@ -1,56 +0,0 @@
-/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-==============================================================================*/
-
-#include "tensorflow/core/kernels/spectrogram_test_utils.h"
-
-#include "tensorflow/core/lib/core/errors.h"
-#include "tensorflow/core/lib/core/status.h"
-#include "tensorflow/core/platform/init_main.h"
-#include "tensorflow/core/platform/logging.h"
-
-namespace tensorflow {
-namespace wav {
-
-// This takes a CSV file representing an array of complex numbers, and saves out
-// a version using a binary format to save space in the repository.
-Status ConvertCsvToRaw(const string& input_filename) {
-  std::vector<std::vector<std::complex<double>>> input_data;
-  ReadCSVFileToComplexVectorOrDie(input_filename, &input_data);
-  const string output_filename = input_filename + ".bin";
-  if (!WriteComplexVectorToRawFloatFile(output_filename, input_data)) {
-    return errors::InvalidArgument("Failed to write raw float file ",
-                                   input_filename);
-  }
-  LOG(INFO) << "Wrote raw file to " << output_filename;
-  return Status::OK();
-}
-
-}  // namespace wav
-}  // namespace tensorflow
-
-int main(int argc, char* argv[]) {
-  tensorflow::port::InitMain(argv[0], &argc, &argv);
-  if (argc < 2) {
-    LOG(ERROR) << "You must supply a CSV file as the first argument";
-    return 1;
-  }
-  tensorflow::string filename(argv[1]);
-  tensorflow::Status status = tensorflow::wav::ConvertCsvToRaw(filename);
-  if (!status.ok()) {
-    LOG(ERROR) << "Error processing '" << filename << "':" << status;
-    return 1;
-  }
-  return 0;
-}
diff --git a/tensorflow/core/kernels/spectrogram_op.cc b/tensorflow/core/kernels/spectrogram_op.cc
deleted file mode 100644
index 98d9bb1ad1..0000000000
--- a/tensorflow/core/kernels/spectrogram_op.cc
+++ /dev/null
@@ -1,120 +0,0 @@
-/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-==============================================================================*/
-
-// See docs in ../ops/audio_ops.cc
-
-#include "tensorflow/core/framework/op_kernel.h"
-#include "tensorflow/core/framework/register_types.h"
-#include "tensorflow/core/framework/tensor.h"
-#include "tensorflow/core/framework/tensor_shape.h"
-#include "tensorflow/core/framework/types.h"
-#include "tensorflow/core/kernels/spectrogram.h"
-#include "tensorflow/core/lib/core/status.h"
-
-namespace tensorflow {
-
-// Create a spectrogram frequency visualization from audio data.
-class SpectrogramOp : public OpKernel {
- public:
-  explicit SpectrogramOp(OpKernelConstruction* context) : OpKernel(context) {
-    OP_REQUIRES_OK(context, context->GetAttr("window_size", &window_size_));
-    OP_REQUIRES_OK(context, context->GetAttr("stride", &stride_));
-    OP_REQUIRES_OK(context,
-                   context->GetAttr("magnitude_squared", &magnitude_squared_));
-  }
-
-  void Compute(OpKernelContext* context) override {
-    const Tensor& input = context->input(0);
-    OP_REQUIRES(context, input.dims() == 2,
-                errors::InvalidArgument("input must be 2-dimensional",
-                                        input.shape().DebugString()));
-    Spectrogram spectrogram;
-    OP_REQUIRES(context, spectrogram.Initialize(window_size_, stride_),
-                errors::InvalidArgument(
-                    "Spectrogram initialization failed for window size ",
-                    window_size_, " and stride ", stride_));
-
-    const auto input_as_matrix = input.matrix<float>();
-
-    const int64 sample_count = input.dim_size(0);
-    const int64 channel_count = input.dim_size(1);
-
-    const int64 output_width = spectrogram.output_frequency_channels();
-    const int64 length_minus_window = (sample_count - window_size_);
-    int64 output_height;
-    if (length_minus_window < 0) {
-      output_height = 0;
-    } else {
-      output_height = 1 + (length_minus_window / stride_);
-    }
-    const int64 output_slices = channel_count;
-
-    Tensor* output_tensor = nullptr;
-    OP_REQUIRES_OK(
-        context,
-        context->allocate_output(
-            0, TensorShape({output_slices, output_height, output_width}),
-            &output_tensor));
-    auto output_flat = output_tensor->flat<float>().data();
-
-    std::vector<float> input_for_channel(sample_count);
-    for (int64 channel = 0; channel < channel_count; ++channel) {
-      float* output_slice =
-          output_flat + (channel * output_height * output_width);
-      for (int i = 0; i < sample_count; ++i) {
-        input_for_channel[i] = input_as_matrix(i, channel);
-      }
-      std::vector<std::vector<float>> spectrogram_output;
-      OP_REQUIRES(context,
-                  spectrogram.ComputeSquaredMagnitudeSpectrogram(
-                      input_for_channel, &spectrogram_output),
-                  errors::InvalidArgument("Spectrogram compute failed"));
-      OP_REQUIRES(context, (spectrogram_output.size() == output_height),
-                  errors::InvalidArgument(
-                      "Spectrogram size calculation failed: Expected height ",
-                      output_height, " but got ", spectrogram_output.size()));
-      OP_REQUIRES(context,
-                  spectrogram_output.empty() ||
-                      (spectrogram_output[0].size() == output_width),
-                  errors::InvalidArgument(
-                      "Spectrogram size calculation failed: Expected width ",
-                      output_width, " but got ", spectrogram_output[0].size()));
-      for (int row_index = 0; row_index < output_height; ++row_index) {
-        const std::vector<float>& spectrogram_row =
-            spectrogram_output[row_index];
-        DCHECK_EQ(spectrogram_row.size(), output_width);
-        float* output_row = output_slice + (row_index * output_width);
-        if (magnitude_squared_) {
-          for (int i = 0; i < output_width; ++i) {
-            output_row[i] = spectrogram_row[i];
-          }
-        } else {
-          for (int i = 0; i < output_width; ++i) {
-            output_row[i] = sqrtf(spectrogram_row[i]);
-          }
-        }
-      }
-    }
-  }
-
- private:
-  int32 window_size_;
-  int32 stride_;
-  bool magnitude_squared_;
-};
-REGISTER_KERNEL_BUILDER(Name("AudioSpectrogram").Device(DEVICE_CPU),
-                        SpectrogramOp);
-
-}  // namespace tensorflow
diff --git a/tensorflow/core/kernels/spectrogram_op_test.cc b/tensorflow/core/kernels/spectrogram_op_test.cc
deleted file mode 100644
index 5c3cbeeeb9..0000000000
--- a/tensorflow/core/kernels/spectrogram_op_test.cc
+++ /dev/null
@@ -1,104 +0,0 @@
-/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-==============================================================================*/
-
-#define EIGEN_USE_THREADS
-
-#include <functional>
-#include <memory>
-#include <vector>
-
-#include "tensorflow/cc/client/client_session.h"
-#include "tensorflow/cc/ops/audio_ops.h"
-#include "tensorflow/cc/ops/const_op.h"
-#include "tensorflow/cc/ops/math_ops.h"
-#include "tensorflow/core/framework/tensor_testutil.h"
-#include "tensorflow/core/framework/types.h"
-#include "tensorflow/core/framework/types.pb.h"
-#include "tensorflow/core/kernels/ops_util.h"
-#include "tensorflow/core/lib/core/status_test_util.h"
-#include "tensorflow/core/platform/test.h"
-
-namespace tensorflow {
-
-using namespace ops;  // NOLINT(build/namespaces)
-
-TEST(SpectrogramOpTest, SimpleTest) {
-  Scope root = Scope::NewRootScope();
-
-  Tensor audio_tensor(DT_FLOAT, TensorShape({8, 1}));
-  test::FillValues<float>(&audio_tensor,
-                          {-1.0f, 0.0f, 1.0f, 0.0f, -1.0f, 0.0f, 1.0f, 0.0f});
-
-  Output audio_const_op = Const(root.WithOpName("audio_const_op"),
-                                Input::Initializer(audio_tensor));
-
-  AudioSpectrogram spectrogram_op =
-      AudioSpectrogram(root.WithOpName("spectrogram_op"), audio_const_op, 8, 1);
-
-  TF_ASSERT_OK(root.status());
-
-  ClientSession session(root);
-  std::vector<Tensor> outputs;
-
-  TF_EXPECT_OK(session.Run(ClientSession::FeedType(),
-                           {spectrogram_op.spectrogram}, &outputs));
-
-  const Tensor& spectrogram_tensor = outputs[0];
-
-  EXPECT_EQ(3, spectrogram_tensor.dims());
-  EXPECT_EQ(5, spectrogram_tensor.dim_size(2));
-  EXPECT_EQ(1, spectrogram_tensor.dim_size(1));
-  EXPECT_EQ(1, spectrogram_tensor.dim_size(0));
-
-  test::ExpectTensorNear<float>(
-      spectrogram_tensor,
-      test::AsTensor<float>({0, 1, 2, 1, 0}, TensorShape({1, 1, 5})), 1e-3);
-}
-
-TEST(SpectrogramOpTest, SquaredTest) {
-  Scope root = Scope::NewRootScope();
-
-  Tensor audio_tensor(DT_FLOAT, TensorShape({8, 1}));
-  test::FillValues<float>(&audio_tensor,
-                          {-1.0f, 0.0f, 1.0f, 0.0f, -1.0f, 0.0f, 1.0f, 0.0f});
-
-  Output audio_const_op = Const(root.WithOpName("audio_const_op"),
-                                Input::Initializer(audio_tensor));
-
-  AudioSpectrogram spectrogram_op =
-      AudioSpectrogram(root.WithOpName("spectrogram_op"), audio_const_op, 8, 1,
-                       AudioSpectrogram::Attrs().MagnitudeSquared(true));
-
-  TF_ASSERT_OK(root.status());
-
-  ClientSession session(root);
-  std::vector<Tensor> outputs;
-
-  TF_EXPECT_OK(session.Run(ClientSession::FeedType(),
-                           {spectrogram_op.spectrogram}, &outputs));
-
-  const Tensor& spectrogram_tensor = outputs[0];
-
-  EXPECT_EQ(3, spectrogram_tensor.dims());
-  EXPECT_EQ(5, spectrogram_tensor.dim_size(2));
-  EXPECT_EQ(1, spectrogram_tensor.dim_size(1));
-  EXPECT_EQ(1, spectrogram_tensor.dim_size(0));
-
-  test::ExpectTensorNear<float>(
-      spectrogram_tensor,
-      test::AsTensor<float>({0, 1, 4, 1, 0}, TensorShape({1, 1, 5})), 1e-3);
-}
-
-}  // namespace tensorflow
diff --git a/tensorflow/core/kernels/spectrogram_test.cc b/tensorflow/core/kernels/spectrogram_test.cc
deleted file mode 100644
index 73175a91a0..0000000000
--- a/tensorflow/core/kernels/spectrogram_test.cc
+++ /dev/null
@@ -1,340 +0,0 @@
-/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-==============================================================================*/
-
-// The MATLAB test data were generated using GenerateTestData.m.
-
-#include "tensorflow/core/kernels/spectrogram.h"
-
-#include <complex>
-#include <vector>
-
-#include "tensorflow/core/kernels/spectrogram_test_utils.h"
-#include "tensorflow/core/lib/core/status_test_util.h"
-#include "tensorflow/core/lib/io/path.h"
-#include "tensorflow/core/platform/test.h"
-#include "tensorflow/core/platform/types.h"
-
-namespace tensorflow {
-
-using ::std::complex;
-
-const char kInputFilename[] =
-    "core/kernels/spectrogram_test_data/short_test_segment.wav";
-
-const char kExpectedFilename[] =
-    "core/kernels/spectrogram_test_data/short_test_segment_spectrogram.csv.bin";
-const int kDataVectorLength = 257;
-const int kNumberOfFramesInTestData = 178;
-
-const char kExpectedNonPowerOfTwoFilename[] =
-    "core/kernels/spectrogram_test_data/"
-    "short_test_segment_spectrogram_400_200.csv.bin";
-const int kNonPowerOfTwoDataVectorLength = 257;
-const int kNumberOfFramesInNonPowerOfTwoTestData = 228;
-
-TEST(SpectrogramTest, TooLittleDataYieldsNoFrames) {
-  Spectrogram sgram;
-  sgram.Initialize(400, 200);
-  std::vector<double> input;
-  // Generate 44 samples of audio.
-  SineWave(44100, 1000.0, 0.001, &input);
-  EXPECT_EQ(44, input.size());
-  std::vector<std::vector<complex<double>>> output;
-  sgram.ComputeComplexSpectrogram(input, &output);
-  EXPECT_EQ(0, output.size());
-}
-
-TEST(SpectrogramTest, StepSizeSmallerThanWindow) {
-  Spectrogram sgram;
-  EXPECT_TRUE(sgram.Initialize(400, 200));
-  std::vector<double> input;
-  // Generate 661 samples of audio.
-  SineWave(44100, 1000.0, 0.015, &input);
-  EXPECT_EQ(661, input.size());
-  std::vector<std::vector<complex<double>>> output;
-  sgram.ComputeComplexSpectrogram(input, &output);
-  EXPECT_EQ(2, output.size());
-}
-
-TEST(SpectrogramTest, StepSizeBiggerThanWindow) {
-  Spectrogram sgram;
-  EXPECT_TRUE(sgram.Initialize(200, 400));
-  std::vector<double> input;
-  // Generate 882 samples of audio.
-  SineWave(44100, 1000.0, 0.02, &input);
-  EXPECT_EQ(882, input.size());
-  std::vector<std::vector<complex<double>>> output;
-  sgram.ComputeComplexSpectrogram(input, &output);
-  EXPECT_EQ(2, output.size());
-}
-
-TEST(SpectrogramTest, StepSizeBiggerThanWindow2) {
-  Spectrogram sgram;
-  EXPECT_TRUE(sgram.Initialize(200, 400));
-  std::vector<double> input;
-  // Generate more than 600 but fewer than 800 samples of audio.
-  SineWave(44100, 1000.0, 0.016, &input);
-  EXPECT_GT(input.size(), 600);
-  EXPECT_LT(input.size(), 800);
-  std::vector<std::vector<complex<double>>> output;
-  sgram.ComputeComplexSpectrogram(input, &output);
-  EXPECT_EQ(2, output.size());
-}
-
-TEST(SpectrogramTest,
-     MultipleCallsToComputeComplexSpectrogramMayYieldDifferentNumbersOfFrames) {
-  // Repeatedly pass inputs with "extra" samples beyond complete windows
-  // and check that the excess points cumulate to eventually cause an
-  // extra output frame.
-  Spectrogram sgram;
-  sgram.Initialize(200, 400);
-  std::vector<double> input;
-  // Generate 882 samples of audio.
-  SineWave(44100, 1000.0, 0.02, &input);
-  EXPECT_EQ(882, input.size());
-  std::vector<std::vector<complex<double>>> output;
-  const std::vector<int> expected_output_sizes = {
-      2,  // One pass of input leaves 82 samples buffered after two steps of
-          // 400.
-      2,  // Passing in 882 samples again will now leave 164 samples buffered.
-      3,  // Third time gives 246 extra samples, triggering an extra output
-          // frame.
-  };
-  for (int expected_output_size : expected_output_sizes) {
-    sgram.ComputeComplexSpectrogram(input, &output);
-    EXPECT_EQ(expected_output_size, output.size());
-  }
-}
-
-TEST(SpectrogramTest, CumulatingExcessInputsForOverlappingFrames) {
-  // Input frames that don't fit into whole windows are cumulated even when
-  // the windows have overlap (similar to
-  // MultipleCallsToComputeComplexSpectrogramMayYieldDifferentNumbersOfFrames
-  // but with window size/hop size swapped).
-  Spectrogram sgram;
-  sgram.Initialize(400, 200);
-  std::vector<double> input;
-  // Generate 882 samples of audio.
-  SineWave(44100, 1000.0, 0.02, &input);
-  EXPECT_EQ(882, input.size());
-  std::vector<std::vector<complex<double>>> output;
-  const std::vector<int> expected_output_sizes = {
-      3,  // Windows 0..400, 200..600, 400..800 with 82 samples buffered.
-      4,  // 1764 frames input; outputs from 600, 800, 1000, 1200..1600.
-      5,  // 2646 frames in; outputs from 1400, 1600, 1800, 2000, 2200..2600.
-  };
-  for (int expected_output_size : expected_output_sizes) {
-    sgram.ComputeComplexSpectrogram(input, &output);
-    EXPECT_EQ(expected_output_size, output.size());
-  }
-}
-
-TEST(SpectrogramTest, StepSizeEqualToWindowWorks) {
-  Spectrogram sgram;
-  sgram.Initialize(200, 200);
-  std::vector<double> input;
-  // Generate 2205 samples of audio.
-  SineWave(44100, 1000.0, 0.05, &input);
-  EXPECT_EQ(2205, input.size());
-  std::vector<std::vector<complex<double>>> output;
-  sgram.ComputeComplexSpectrogram(input, &output);
-  EXPECT_EQ(11, output.size());
-}
-
-template <class ExpectedSample, class ActualSample>
-void CompareComplexData(
-    const std::vector<std::vector<complex<ExpectedSample>>>& expected,
-    const std::vector<std::vector<complex<ActualSample>>>& actual,
-    double tolerance) {
-  ASSERT_EQ(actual.size(), expected.size());
-  for (int i = 0; i < expected.size(); ++i) {
-    ASSERT_EQ(expected[i].size(), actual[i].size());
-    for (int j = 0; j < expected[i].size(); ++j) {
-      ASSERT_NEAR(real(expected[i][j]), real(actual[i][j]), tolerance)
-          << ": where i=" << i << " and j=" << j << ".";
-      ASSERT_NEAR(imag(expected[i][j]), imag(actual[i][j]), tolerance)
-          << ": where i=" << i << " and j=" << j << ".";
-    }
-  }
-}
-
-template <class Sample>
-double GetMaximumAbsolute(const std::vector<std::vector<Sample>>& spectrogram) {
-  double max_absolute = 0.0;
-  for (int i = 0; i < spectrogram.size(); ++i) {
-    for (int j = 0; j < spectrogram[i].size(); ++j) {
-      double absolute_value = std::abs(spectrogram[i][j]);
-      if (absolute_value > max_absolute) {
-        max_absolute = absolute_value;
-      }
-    }
-  }
-  return max_absolute;
-}
-
-template <class ExpectedSample, class ActualSample>
-void CompareMagnitudeData(
-    const std::vector<std::vector<complex<ExpectedSample>>>&
-        expected_complex_output,
-    const std::vector<std::vector<ActualSample>>& actual_squared_magnitude,
-    double tolerance) {
-  ASSERT_EQ(actual_squared_magnitude.size(), expected_complex_output.size());
-  for (int i = 0; i < expected_complex_output.size(); ++i) {
-    ASSERT_EQ(expected_complex_output[i].size(),
-              actual_squared_magnitude[i].size());
-    for (int j = 0; j < expected_complex_output[i].size(); ++j) {
-      ASSERT_NEAR(norm(expected_complex_output[i][j]),
-                  actual_squared_magnitude[i][j], tolerance)
-          << ": where i=" << i << " and j=" << j << ".";
-    }
-  }
-}
-
-TEST(SpectrogramTest, ReInitializationWorks) {
-  Spectrogram sgram;
-  sgram.Initialize(512, 256);
-  std::vector<double> input;
-  CHECK(ReadWaveFileToVector(
-      tensorflow::io::JoinPath(testing::TensorFlowSrcRoot(), kInputFilename),
-      &input));
-  std::vector<std::vector<complex<double>>> first_output;
-  std::vector<std::vector<complex<double>>> second_output;
-  sgram.Initialize(512, 256);
-  sgram.ComputeComplexSpectrogram(input, &first_output);
-  // Re-Initialize it.
-  sgram.Initialize(512, 256);
-  sgram.ComputeComplexSpectrogram(input, &second_output);
-  // Verify identical outputs.
-  ASSERT_EQ(first_output.size(), second_output.size());
-  int slice_size = first_output[0].size();
-  for (int i = 0; i < first_output.size(); ++i) {
-    ASSERT_EQ(slice_size, first_output[i].size());
-    ASSERT_EQ(slice_size, second_output[i].size());
-    for (int j = 0; j < slice_size; ++j) {
-      ASSERT_EQ(first_output[i][j], second_output[i][j]);
-    }
-  }
-}
-
-TEST(SpectrogramTest, ComputedComplexDataAgreeWithMatlab) {
-  const int kInputDataLength = 45870;
-  Spectrogram sgram;
-  sgram.Initialize(512, 256);
-  std::vector<double> input;
-  CHECK(ReadWaveFileToVector(
-      tensorflow::io::JoinPath(testing::TensorFlowSrcRoot(), kInputFilename),
-      &input));
-  EXPECT_EQ(kInputDataLength, input.size());
-  std::vector<std::vector<complex<double>>> expected_output;
-  ASSERT_TRUE(ReadRawFloatFileToComplexVector(
-      tensorflow::io::JoinPath(testing::TensorFlowSrcRoot(), kExpectedFilename),
-      kDataVectorLength, &expected_output));
-  EXPECT_EQ(kNumberOfFramesInTestData, expected_output.size());
-  EXPECT_EQ(kDataVectorLength, expected_output[0].size());
-  std::vector<std::vector<complex<double>>> output;
-  sgram.ComputeComplexSpectrogram(input, &output);
-  CompareComplexData(expected_output, output, 1e-5);
-}
-
-TEST(SpectrogramTest, ComputedFloatComplexDataAgreeWithMatlab) {
-  const int kInputDataLength = 45870;
-  Spectrogram sgram;
-  sgram.Initialize(512, 256);
-  std::vector<double> double_input;
-  CHECK(ReadWaveFileToVector(
-      tensorflow::io::JoinPath(testing::TensorFlowSrcRoot(), kInputFilename),
-      &double_input));
-  std::vector<float> input;
-  input.assign(double_input.begin(), double_input.end());
-  EXPECT_EQ(kInputDataLength, input.size());
-  std::vector<std::vector<complex<double>>> expected_output;
-  ASSERT_TRUE(ReadRawFloatFileToComplexVector(
-      tensorflow::io::JoinPath(testing::TensorFlowSrcRoot(), kExpectedFilename),
-      kDataVectorLength, &expected_output));
-  EXPECT_EQ(kNumberOfFramesInTestData, expected_output.size());
-  EXPECT_EQ(kDataVectorLength, expected_output[0].size());
-  std::vector<std::vector<complex<float>>> output;
-  sgram.ComputeComplexSpectrogram(input, &output);
-  CompareComplexData(expected_output, output, 1e-4);
-}
-
-TEST(SpectrogramTest, ComputedSquaredMagnitudeDataAgreeWithMatlab) {
-  const int kInputDataLength = 45870;
-  Spectrogram sgram;
-  sgram.Initialize(512, 256);
-  std::vector<double> input;
-  CHECK(ReadWaveFileToVector(
-      tensorflow::io::JoinPath(testing::TensorFlowSrcRoot(), kInputFilename),
-      &input));
-  EXPECT_EQ(kInputDataLength, input.size());
-  std::vector<std::vector<complex<double>>> expected_output;
-  ASSERT_TRUE(ReadRawFloatFileToComplexVector(
-      tensorflow::io::JoinPath(testing::TensorFlowSrcRoot(), kExpectedFilename),
-      kDataVectorLength, &expected_output));
-  EXPECT_EQ(kNumberOfFramesInTestData, expected_output.size());
-  EXPECT_EQ(kDataVectorLength, expected_output[0].size());
-  std::vector<std::vector<double>> output;
-  sgram.ComputeSquaredMagnitudeSpectrogram(input, &output);
-  CompareMagnitudeData(expected_output, output, 1e-3);
-}
-
-TEST(SpectrogramTest, ComputedFloatSquaredMagnitudeDataAgreeWithMatlab) {
-  const int kInputDataLength = 45870;
-  Spectrogram sgram;
-  sgram.Initialize(512, 256);
-  std::vector<double> double_input;
-  CHECK(ReadWaveFileToVector(
-      tensorflow::io::JoinPath(testing::TensorFlowSrcRoot(), kInputFilename),
-      &double_input));
-  EXPECT_EQ(kInputDataLength, double_input.size());
-  std::vector<float> input;
-  input.assign(double_input.begin(), double_input.end());
-  std::vector<std::vector<complex<double>>> expected_output;
-  ASSERT_TRUE(ReadRawFloatFileToComplexVector(
-      tensorflow::io::JoinPath(testing::TensorFlowSrcRoot(), kExpectedFilename),
-      kDataVectorLength, &expected_output));
-  EXPECT_EQ(kNumberOfFramesInTestData, expected_output.size());
-  EXPECT_EQ(kDataVectorLength, expected_output[0].size());
-  std::vector<std::vector<float>> output;
-  sgram.ComputeSquaredMagnitudeSpectrogram(input, &output);
-  double max_absolute = GetMaximumAbsolute(output);
-  EXPECT_GT(max_absolute, 2300.0);  // Verify that we have some big numbers.
-  // Squaring increases dynamic range; max square is about 2300,
-  // so 2e-4 is about 7 decimal digits; not bad for a float.
-  CompareMagnitudeData(expected_output, output, 2e-4);
-}
-
-TEST(SpectrogramTest, ComputedNonPowerOfTwoComplexDataAgreeWithMatlab) {
-  const int kInputDataLength = 45870;
-  Spectrogram sgram;
-  sgram.Initialize(400, 200);
-  std::vector<double> input;
-  CHECK(ReadWaveFileToVector(
-      tensorflow::io::JoinPath(testing::TensorFlowSrcRoot(), kInputFilename),
-      &input));
-  EXPECT_EQ(kInputDataLength, input.size());
-  std::vector<std::vector<complex<double>>> expected_output;
-  ASSERT_TRUE(ReadRawFloatFileToComplexVector(
-      tensorflow::io::JoinPath(testing::TensorFlowSrcRoot(),
-                               kExpectedNonPowerOfTwoFilename),
-      kNonPowerOfTwoDataVectorLength, &expected_output));
-  EXPECT_EQ(kNumberOfFramesInNonPowerOfTwoTestData, expected_output.size());
-  EXPECT_EQ(kNonPowerOfTwoDataVectorLength, expected_output[0].size());
-  std::vector<std::vector<complex<double>>> output;
-  sgram.ComputeComplexSpectrogram(input, &output);
-  CompareComplexData(expected_output, output, 1e-5);
-}
-
-}  // namespace tensorflow
diff --git a/tensorflow/core/kernels/spectrogram_test_data/README b/tensorflow/core/kernels/spectrogram_test_data/README
deleted file mode 100644
index 271238e0c9..0000000000
--- a/tensorflow/core/kernels/spectrogram_test_data/README
+++ /dev/null
@@ -1,8 +0,0 @@
-The CSV spectrogram files in this directory are generated from the
-matlab code in ./matlab/GenerateTestData.m
-To save space in the repo, you'll then need to convert them into a binary packed
-format using the convert_test_data.cc command line tool.
-
-
-short_test_segment.wav is approximately 1s of music audio.
-
diff --git a/tensorflow/core/kernels/spectrogram_test_data/short_test_segment.wav b/tensorflow/core/kernels/spectrogram_test_data/short_test_segment.wav
deleted file mode 100644
index 7339dfd08c..0000000000
--- a/tensorflow/core/kernels/spectrogram_test_data/short_test_segment.wav
+++ /dev/null
diff --git a/tensorflow/core/kernels/spectrogram_test_data/short_test_segment_spectrogram.csv.bin b/tensorflow/core/kernels/spectrogram_test_data/short_test_segment_spectrogram.csv.bin
deleted file mode 100644
index 67b9e2487c..0000000000
--- a/tensorflow/core/kernels/spectrogram_test_data/short_test_segment_spectrogram.csv.bin
+++ /dev/null
diff --git a/tensorflow/core/kernels/spectrogram_test_data/short_test_segment_spectrogram_400_200.csv.bin b/tensorflow/core/kernels/spectrogram_test_data/short_test_segment_spectrogram_400_200.csv.bin
deleted file mode 100644
index d5e4cc5dd6..0000000000
--- a/tensorflow/core/kernels/spectrogram_test_data/short_test_segment_spectrogram_400_200.csv.bin
+++ /dev/null
diff --git a/tensorflow/core/kernels/spectrogram_test_utils.cc b/tensorflow/core/kernels/spectrogram_test_utils.cc
deleted file mode 100644
index a2141c649f..0000000000
--- a/tensorflow/core/kernels/spectrogram_test_utils.cc
+++ /dev/null
@@ -1,288 +0,0 @@
-/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-==============================================================================*/
-
-#include "tensorflow/core/kernels/spectrogram_test_utils.h"
-
-#include <math.h>
-#include <stddef.h>
-
-#include "tensorflow/core/lib/core/error_codes.pb.h"
-#include "tensorflow/core/lib/core/status_test_util.h"
-#include "tensorflow/core/lib/io/path.h"
-#include "tensorflow/core/lib/strings/str_util.h"
-#include "tensorflow/core/lib/wav/wav_io.h"
-#include "tensorflow/core/platform/env.h"
-#include "tensorflow/core/platform/test.h"
-#include "tensorflow/core/platform/types.h"
-
-namespace tensorflow {
-
-bool ReadWaveFileToVector(const string& file_name, std::vector<double>* data) {
-  string wav_data;
-  if (!ReadFileToString(Env::Default(), file_name, &wav_data).ok()) {
-    LOG(ERROR) << "Wave file read failed for " << file_name;
-    return false;
-  }
-  std::vector<float> decoded_data;
-  uint32 decoded_sample_count;
-  uint16 decoded_channel_count;
-  uint32 decoded_sample_rate;
-  if (!wav::DecodeLin16WaveAsFloatVector(
-           wav_data, &decoded_data, &decoded_sample_count,
-           &decoded_channel_count, &decoded_sample_rate)
-           .ok()) {
-    return false;
-  }
-  // Convert from float to double for the output value.
-  data->resize(decoded_data.size());
-  for (int i = 0; i < decoded_data.size(); ++i) {
-    (*data)[i] = decoded_data[i];
-  }
-  return true;
-}
-
-bool ReadRawFloatFileToComplexVector(
-    const string& file_name, int row_length,
-    std::vector<std::vector<std::complex<double> > >* data) {
-  data->clear();
-  string data_string;
-  if (!ReadFileToString(Env::Default(), file_name, &data_string).ok()) {
-    LOG(ERROR) << "Failed to open file " << file_name;
-    return false;
-  }
-  float real_out;
-  float imag_out;
-  const int kBytesPerValue = 4;
-  CHECK_EQ(sizeof(real_out), kBytesPerValue);
-  std::vector<std::complex<double> > data_row;
-  int row_counter = 0;
-  int offset = 0;
-  const int end = data_string.size();
-  while (offset < end) {
-    memcpy(&real_out, data_string.data() + offset, kBytesPerValue);
-    offset += kBytesPerValue;
-    memcpy(&imag_out, data_string.data() + offset, kBytesPerValue);
-    offset += kBytesPerValue;
-    if (row_counter >= row_length) {
-      data->push_back(data_row);
-      data_row.clear();
-      row_counter = 0;
-    }
-    data_row.push_back(std::complex<double>(real_out, imag_out));
-    ++row_counter;
-  }
-  if (row_counter >= row_length) {
-    data->push_back(data_row);
-  }
-  return true;
-}
-
-void ReadCSVFileToComplexVectorOrDie(
-    const string& file_name,
-    std::vector<std::vector<std::complex<double> > >* data) {
-  data->clear();
-  string data_string;
-  if (!ReadFileToString(Env::Default(), file_name, &data_string).ok()) {
-    LOG(FATAL) << "Failed to open file " << file_name;
-    return;
-  }
-  std::vector<string> lines = str_util::Split(data_string, '\n');
-  for (const string& line : lines) {
-    if (line == "") {
-      continue;
-    }
-    std::vector<std::complex<double> > data_line;
-    std::vector<string> values = str_util::Split(line, ',');
-    for (std::vector<string>::const_iterator i = values.begin();
-         i != values.end(); ++i) {
-      // each element of values may be in the form:
-      // 0.001+0.002i, 0.001, 0.001i, -1.2i, -1.2-3.2i, 1.5, 1.5e-03+21.0i
-      std::vector<string> parts;
-      // Find the first instance of + or - after the second character
-      // in the string, that does not immediately follow an 'e'.
-      size_t operator_index = i->find_first_of("+-", 2);
-      if (operator_index < i->size() &&
-          i->substr(operator_index - 1, 1) == "e") {
-        operator_index = i->find_first_of("+-", operator_index + 1);
-      }
-      parts.push_back(i->substr(0, operator_index));
-      if (operator_index < i->size()) {
-        parts.push_back(i->substr(operator_index, string::npos));
-      }
-
-      double real_part = 0.0;
-      double imaginary_part = 0.0;
-      for (std::vector<string>::const_iterator j = parts.begin();
-           j != parts.end(); ++j) {
-        if (j->find_first_of("ij") != string::npos) {
-          strings::safe_strtod((*j).c_str(), &imaginary_part);
-        } else {
-          strings::safe_strtod((*j).c_str(), &real_part);
-        }
-      }
-      data_line.push_back(std::complex<double>(real_part, imaginary_part));
-    }
-    data->push_back(data_line);
-  }
-}
-
-void ReadCSVFileToArrayOrDie(const string& filename,
-                             std::vector<std::vector<float> >* array) {
-  string contents;
-  TF_CHECK_OK(ReadFileToString(Env::Default(), filename, &contents));
-  std::vector<string> lines = str_util::Split(contents, '\n');
-  contents.clear();
-
-  array->clear();
-  std::vector<float> values;
-  for (int l = 0; l < lines.size(); ++l) {
-    values.clear();
-    CHECK(str_util::SplitAndParseAsFloats(lines[l], ',', &values));
-    array->push_back(values);
-  }
-}
-
-bool WriteDoubleVectorToFile(const string& file_name,
-                             const std::vector<double>& data) {
-  std::unique_ptr<WritableFile> file;
-  if (!Env::Default()->NewWritableFile(file_name, &file).ok()) {
-    LOG(ERROR) << "Failed to open file " << file_name;
-    return false;
-  }
-  for (int i = 0; i < data.size(); ++i) {
-    if (!file->Append(StringPiece(reinterpret_cast<const char*>(&(data[i])),
-                                  sizeof(data[i])))
-             .ok()) {
-      LOG(ERROR) << "Failed to append to file " << file_name;
-      return false;
-    }
-  }
-  if (!file->Close().ok()) {
-    LOG(ERROR) << "Failed to close file " << file_name;
-    return false;
-  }
-  return true;
-}
-
-bool WriteFloatVectorToFile(const string& file_name,
-                            const std::vector<float>& data) {
-  std::unique_ptr<WritableFile> file;
-  if (!Env::Default()->NewWritableFile(file_name, &file).ok()) {
-    LOG(ERROR) << "Failed to open file " << file_name;
-    return false;
-  }
-  for (int i = 0; i < data.size(); ++i) {
-    if (!file->Append(StringPiece(reinterpret_cast<const char*>(&(data[i])),
-                                  sizeof(data[i])))
-             .ok()) {
-      LOG(ERROR) << "Failed to append to file " << file_name;
-      return false;
-    }
-  }
-  if (!file->Close().ok()) {
-    LOG(ERROR) << "Failed to close file " << file_name;
-    return false;
-  }
-  return true;
-}
-
-bool WriteDoubleArrayToFile(const string& file_name, int size,
-                            const double* data) {
-  std::unique_ptr<WritableFile> file;
-  if (!Env::Default()->NewWritableFile(file_name, &file).ok()) {
-    LOG(ERROR) << "Failed to open file " << file_name;
-    return false;
-  }
-  for (int i = 0; i < size; ++i) {
-    if (!file->Append(StringPiece(reinterpret_cast<const char*>(&(data[i])),
-                                  sizeof(data[i])))
-             .ok()) {
-      LOG(ERROR) << "Failed to append to file " << file_name;
-      return false;
-    }
-  }
-  if (!file->Close().ok()) {
-    LOG(ERROR) << "Failed to close file " << file_name;
-    return false;
-  }
-  return true;
-}
-
-bool WriteFloatArrayToFile(const string& file_name, int size,
-                           const float* data) {
-  std::unique_ptr<WritableFile> file;
-  if (!Env::Default()->NewWritableFile(file_name, &file).ok()) {
-    LOG(ERROR) << "Failed to open file " << file_name;
-    return false;
-  }
-  for (int i = 0; i < size; ++i) {
-    if (!file->Append(StringPiece(reinterpret_cast<const char*>(&(data[i])),
-                                  sizeof(data[i])))
-             .ok()) {
-      LOG(ERROR) << "Failed to append to file " << file_name;
-      return false;
-    }
-  }
-  if (!file->Close().ok()) {
-    LOG(ERROR) << "Failed to close file " << file_name;
-    return false;
-  }
-  return true;
-}
-
-bool WriteComplexVectorToRawFloatFile(
-    const string& file_name,
-    const std::vector<std::vector<std::complex<double> > >& data) {
-  std::unique_ptr<WritableFile> file;
-  if (!Env::Default()->NewWritableFile(file_name, &file).ok()) {
-    LOG(ERROR) << "Failed to open file " << file_name;
-    return false;
-  }
-  for (int i = 0; i < data.size(); ++i) {
-    for (int j = 0; j < data[i].size(); ++j) {
-      const float real_part(real(data[i][j]));
-      if (!file->Append(StringPiece(reinterpret_cast<const char*>(&real_part),
-                                    sizeof(real_part)))
-               .ok()) {
-        LOG(ERROR) << "Failed to append to file " << file_name;
-        return false;
-      }
-
-      const float imag_part(imag(data[i][j]));
-      if (!file->Append(StringPiece(reinterpret_cast<const char*>(&imag_part),
-                                    sizeof(imag_part)))
-               .ok()) {
-        LOG(ERROR) << "Failed to append to file " << file_name;
-        return false;
-      }
-    }
-  }
-  if (!file->Close().ok()) {
-    LOG(ERROR) << "Failed to close file " << file_name;
-    return false;
-  }
-  return true;
-}
-
-void SineWave(int sample_rate, float frequency, float duration_seconds,
-              std::vector<double>* data) {
-  data->clear();
-  for (int i = 0; i < static_cast<int>(sample_rate * duration_seconds); ++i) {
-    data->push_back(
-        sin(2.0 * M_PI * i * frequency / static_cast<double>(sample_rate)));
-  }
-}
-
-}  // namespace tensorflow
diff --git a/tensorflow/core/kernels/spectrogram_test_utils.h b/tensorflow/core/kernels/spectrogram_test_utils.h
deleted file mode 100644
index 59a903549e..0000000000
--- a/tensorflow/core/kernels/spectrogram_test_utils.h
+++ /dev/null
@@ -1,81 +0,0 @@
-/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-==============================================================================*/
-
-#ifndef THIRD_PARTY_TENSORFLOW_CORE_KERNELS_SPECTROGRAM_TEST_UTILS_H_
-#define THIRD_PARTY_TENSORFLOW_CORE_KERNELS_SPECTROGRAM_TEST_UTILS_H_
-
-#include <complex>
-#include <string>
-#include <vector>
-
-#include "tensorflow/core/framework/types.h"
-
-namespace tensorflow {
-
-// Reads a wav format file into a vector of floating-point values with range
-// -1.0 to 1.0.
-bool ReadWaveFileToVector(const string& file_name, std::vector<double>* data);
-
-// Reads a binary file containing 32-bit floating point values in the
-// form [real_1, imag_1, real_2, imag_2, ...] into a rectangular array
-// of complex values where row_length is the length of each inner vector.
-bool ReadRawFloatFileToComplexVector(
-    const string& file_name, int row_length,
-    std::vector<std::vector<std::complex<double> > >* data);
-
-// Reads a CSV file of numbers in the format 1.1+2.2i,1.1,2.2i,3.3j into data.
-void ReadCSVFileToComplexVectorOrDie(
-    const string& file_name,
-    std::vector<std::vector<std::complex<double> > >* data);
-
-// Reads a 2D array of floats from an ASCII text file, where each line is a row
-// of the array, and elements are separated by commas.
-void ReadCSVFileToArrayOrDie(const string& filename,
-                             std::vector<std::vector<float> >* array);
-
-// Write a binary file containing 64-bit floating-point values for
-// reading by, for example, MATLAB.
-bool WriteDoubleVectorToFile(const string& file_name,
-                             const std::vector<double>& data);
-
-// Write a binary file containing 32-bit floating-point values for
-// reading by, for example, MATLAB.
-bool WriteFloatVectorToFile(const string& file_name,
-                            const std::vector<float>& data);
-
-// Write a binary file containing 64-bit floating-point values for
-// reading by, for example, MATLAB.
-bool WriteDoubleArrayToFile(const string& file_name, int size,
-                            const double* data);
-
-// Write a binary file containing 32-bit floating-point values for
-// reading by, for example, MATLAB.
-bool WriteFloatArrayToFile(const string& file_name, int size,
-                           const float* data);
-
-// Write a binary file in the format read by
-// ReadRawDoubleFileToComplexVector above.
-bool WriteComplexVectorToRawFloatFile(
-    const string& file_name,
-    const std::vector<std::vector<std::complex<double> > >& data);
-
-// Generate a sine wave with the provided parameters, and populate
-// data with the samples.
-void SineWave(int sample_rate, float frequency, float duration_seconds,
-              std::vector<double>* data);
-
-}  // namespace tensorflow
-
-#endif  // THIRD_PARTY_TENSORFLOW_CORE_KERNELS_SPECTROGRAM_TEST_UTILS_H_
diff --git a/tensorflow/core/lib/core/bits.h b/tensorflow/core/lib/core/bits.h
index 1110ef5c2a..30ad0c2bea 100644
--- a/tensorflow/core/lib/core/bits.h
+++ b/tensorflow/core/lib/core/bits.h
@@ -16,7 +16,6 @@ limitations under the License.
 #ifndef TENSORFLOW_LIB_CORE_BITS_H_
 #define TENSORFLOW_LIB_CORE_BITS_H_
 
-#include "tensorflow/core/platform/logging.h"
 #include "tensorflow/core/platform/types.h"
 
 namespace tensorflow {
@@ -92,18 +91,6 @@ inline int Log2Ceiling64(uint64 n) {
     return floor + 1;
 }
 
-inline uint32 NextPowerOfTwo(uint32 value) {
-  int exponent = Log2Ceiling(value);
-  DCHECK_LT(exponent, std::numeric_limits<uint32>::digits);
-  return 1 << exponent;
-}
-
-inline uint64 NextPowerOfTwo64(uint64 value) {
-  int exponent = Log2Ceiling(value);
-  DCHECK_LT(exponent, std::numeric_limits<uint64>::digits);
-  return 1LL << exponent;
-}
-
 }  // namespace tensorflow
 
 #endif  // TENSORFLOW_LIB_CORE_BITS_H_
diff --git a/tensorflow/core/ops/audio_ops.cc b/tensorflow/core/ops/audio_ops.cc
index 2f55e45e37..d6dedc3820 100644
--- a/tensorflow/core/ops/audio_ops.cc
+++ b/tensorflow/core/ops/audio_ops.cc
@@ -16,7 +16,6 @@ limitations under the License.
 #include "tensorflow/core/framework/common_shape_fns.h"
 #include "tensorflow/core/framework/op.h"
 #include "tensorflow/core/framework/shape_inference.h"
-#include "tensorflow/core/lib/core/bits.h"
 
 namespace tensorflow {
 
@@ -67,39 +66,6 @@ Status EncodeWavShapeFn(InferenceContext* c) {
   return Status::OK();
 }
 
-Status SpectrogramShapeFn(InferenceContext* c) {
-  ShapeHandle input;
-  TF_RETURN_IF_ERROR(c->WithRank(c->input(0), 2, &input));
-  int32 window_size;
-  TF_RETURN_IF_ERROR(c->GetAttr("window_size", &window_size));
-  int32 stride;
-  TF_RETURN_IF_ERROR(c->GetAttr("stride", &stride));
-
-  DimensionHandle input_channels = c->Dim(input, 0);
-  DimensionHandle input_length = c->Dim(input, 1);
-
-  DimensionHandle output_length;
-  if (!c->ValueKnown(input_length)) {
-    output_length = c->UnknownDim();
-  } else {
-    const int64 input_length_value = c->Value(input_length);
-    const int64 length_minus_window = (input_length_value - window_size);
-    int64 output_length_value;
-    if (length_minus_window < 0) {
-      output_length_value = 0;
-    } else {
-      output_length_value = 1 + (length_minus_window / stride);
-    }
-    output_length = c->MakeDim(output_length_value);
-  }
-
-  DimensionHandle output_channels =
-      c->MakeDim(1 + NextPowerOfTwo(window_size) / 2);
-  c->set_output(0,
-                c->MakeShape({input_channels, output_length, output_channels}));
-  return Status::OK();
-}
-
 }  // namespace
 
 REGISTER_OP("DecodeWav")
@@ -155,49 +121,4 @@ sample_rate: Scalar containing the sample frequency.
 contents: 0-D. WAV-encoded file contents.
 )doc");
 
-REGISTER_OP("AudioSpectrogram")
-    .Input("input: float")
-    .Attr("window_size: int")
-    .Attr("stride: int")
-    .Attr("magnitude_squared: bool = false")
-    .Output("spectrogram: float")
-    .SetShapeFn(SpectrogramShapeFn)
-    .Doc(R"doc(
-Produces a visualization of audio data over time.
-
-Spectrograms are a standard way of representing audio information as a series of
-slices of frequency information, one slice for each window of time. By joining
-these together into a sequence, they form a distinctive fingerprint of the sound
-over time.
-
-This op expects to receive audio data as an input, stored as floats in the range
--1 to 1, together with a window width in samples, and a stride specifying how
-far to move the window between slices. From this it generates a three
-dimensional output. The lowest dimension has an amplitude value for each
-frequency during that time slice. The next dimension is time, with successive
-frequency slices. The final dimension is for the channels in the input, so a
-stereo audio input would have two here for example.
-
-This means the layout when converted and saved as an image is rotated 90 degrees
-clockwise from a typical spectrogram. Time is descending down the Y axis, and
-the frequency decreases from left to right.
-
-Each value in the result represents the square root of the sum of the real and
-imaginary parts of an FFT on the current window of samples. In this way, the
-lowest dimension represents the power of each frequency in the current window,
-and adjacent windows are concatenated in the next dimension.
-
-To get a more intuitive and visual look at what this operation does, you can run
-tensorflow/examples/wav_to_spectrogram to read in an audio file and save out the
-resulting spectrogram as a PNG image.
-
-input: Float representation of audio data.
-window_size: How wide the input window is in samples. For the highest efficiency
-  this should be a power of two, but other values are accepted.
-stride: How widely apart the center of adjacent sample windows should be.
-magnitude_squared: Whether to return the squared magnitude or just the
-  magnitude. Using squared magnitude can avoid extra calculations.
-spectrogram: 3D representation of the audio frequencies as an image.
-)doc");
-
 }  // namespace tensorflow
diff --git a/tensorflow/core/platform/default/build_config/BUILD b/tensorflow/core/platform/default/build_config/BUILD
index 62af852173..0857010f7c 100644
--- a/tensorflow/core/platform/default/build_config/BUILD
+++ b/tensorflow/core/platform/default/build_config/BUILD
@@ -92,7 +92,6 @@ cc_library(
         "//tensorflow/core:protos_cc",
         "@com_googlesource_code_re2//:re2",
         "@farmhash_archive//:farmhash",
-        "@fft2d//:fft2d",
         "@highwayhash//:sip_hash",
         "@png_archive//:png",
     ],
diff --git a/tensorflow/core/util/command_line_flags.cc b/tensorflow/core/util/command_line_flags.cc
index 8373eb1f9e..03eb076f30 100644
--- a/tensorflow/core/util/command_line_flags.cc
+++ b/tensorflow/core/util/command_line_flags.cc
@@ -93,22 +93,6 @@ bool ParseBoolFlag(tensorflow::StringPiece arg, tensorflow::StringPiece flag,
   return false;
 }
 
-bool ParseFloatFlag(tensorflow::StringPiece arg, tensorflow::StringPiece flag,
-                    float* dst, bool* value_parsing_ok) {
-  *value_parsing_ok = true;
-  if (arg.Consume("--") && arg.Consume(flag) && arg.Consume("=")) {
-    char extra;
-    if (sscanf(arg.data(), "%f%c", dst, &extra) != 1) {
-      LOG(ERROR) << "Couldn't interpret value " << arg << " for flag " << flag
-                 << ".";
-      *value_parsing_ok = false;
-    }
-    return true;
-  }
-
-  return false;
-}
-
 }  // namespace
 
 Flag::Flag(const char* name, tensorflow::int32* dst, const string& usage_text)
@@ -132,12 +116,6 @@ Flag::Flag(const char* name, string* dst, const string& usage_text)
       string_value_(dst),
       usage_text_(usage_text) {}
 
-Flag::Flag(const char* name, float* dst, const string& usage_text)
-    : name_(name),
-      type_(TYPE_FLOAT),
-      float_value_(dst),
-      usage_text_(usage_text) {}
-
 bool Flag::Parse(string arg, bool* value_parsing_ok) const {
   bool result = false;
   if (type_ == TYPE_INT) {
@@ -148,8 +126,6 @@ bool Flag::Parse(string arg, bool* value_parsing_ok) const {
     result = ParseBoolFlag(arg, name_, bool_value_, value_parsing_ok);
   } else if (type_ == TYPE_STRING) {
     result = ParseStringFlag(arg, name_, string_value_, value_parsing_ok);
-  } else if (type_ == TYPE_FLOAT) {
-    result = ParseFloatFlag(arg, name_, float_value_, value_parsing_ok);
   }
   return result;
 }
@@ -219,10 +195,6 @@ bool Flag::Parse(string arg, bool* value_parsing_ok) const {
       type_name = "string";
       flag_string = strings::Printf("--%s=\"%s\"", flag.name_.c_str(),
                                     flag.string_value_->c_str());
-    } else if (flag.type_ == Flag::TYPE_FLOAT) {
-      type_name = "float";
-      flag_string =
-          strings::Printf("--%s=%f", flag.name_.c_str(), *flag.float_value_);
     }
     strings::Appendf(&usage_text, "\t%-33s\t%s\t%s\n", flag_string.c_str(),
                      type_name, flag.usage_text_.c_str());
diff --git a/tensorflow/core/util/command_line_flags.h b/tensorflow/core/util/command_line_flags.h
index f349df16fd..2c77d7874f 100644
--- a/tensorflow/core/util/command_line_flags.h
+++ b/tensorflow/core/util/command_line_flags.h
@@ -65,7 +65,6 @@ class Flag {
   Flag(const char* name, int64* dst1, const string& usage_text);
   Flag(const char* name, bool* dst, const string& usage_text);
   Flag(const char* name, string* dst, const string& usage_text);
-  Flag(const char* name, float* dst, const string& usage_text);
 
  private:
   friend class Flags;
@@ -73,12 +72,11 @@ class Flag {
   bool Parse(string arg, bool* value_parsing_ok) const;
 
   string name_;
-  enum { TYPE_INT, TYPE_INT64, TYPE_BOOL, TYPE_STRING, TYPE_FLOAT } type_;
+  enum { TYPE_INT, TYPE_INT64, TYPE_BOOL, TYPE_STRING } type_;
   int* int_value_;
   int64* int64_value_;
   bool* bool_value_;
   string* string_value_;
-  float* float_value_;
   string usage_text_;
 };
 
diff --git a/tensorflow/core/util/command_line_flags_test.cc b/tensorflow/core/util/command_line_flags_test.cc
index 62025463af..b002e35899 100644
--- a/tensorflow/core/util/command_line_flags_test.cc
+++ b/tensorflow/core/util/command_line_flags_test.cc
@@ -32,35 +32,29 @@ std::vector<char *> CharPointerVectorFromStrings(
   }
   return result;
 }
-}  // namespace
+}
 
 TEST(CommandLineFlagsTest, BasicUsage) {
   int some_int = 10;
   int64 some_int64 = 21474836470;  // max int32 is 2147483647
   bool some_switch = false;
   string some_name = "something";
-  float some_float = -23.23f;
-  int argc = 6;
-  std::vector<string> argv_strings = {"program_name",
-                                      "--some_int=20",
-                                      "--some_int64=214748364700",
-                                      "--some_switch",
-                                      "--some_name=somethingelse",
-                                      "--some_float=42.0"};
+  int argc = 5;
+  std::vector<string> argv_strings = {
+      "program_name", "--some_int=20", "--some_int64=214748364700",
+      "--some_switch", "--some_name=somethingelse"};
   std::vector<char *> argv_array = CharPointerVectorFromStrings(argv_strings);
   bool parsed_ok =
       Flags::Parse(&argc, argv_array.data(),
                    {Flag("some_int", &some_int, "some int"),
                     Flag("some_int64", &some_int64, "some int64"),
                     Flag("some_switch", &some_switch, "some switch"),
-                    Flag("some_name", &some_name, "some name"),
-                    Flag("some_float", &some_float, "some float")});
+                    Flag("some_name", &some_name, "some name")});
   EXPECT_EQ(true, parsed_ok);
   EXPECT_EQ(20, some_int);
   EXPECT_EQ(214748364700, some_int64);
   EXPECT_EQ(true, some_switch);
   EXPECT_EQ("somethingelse", some_name);
-  EXPECT_NEAR(42.0f, some_float, 1e-5f);
   EXPECT_EQ(argc, 1);
 }
 
@@ -91,21 +85,6 @@ TEST(CommandLineFlagsTest, BadBoolValue) {
   EXPECT_EQ(argc, 1);
 }
 
-TEST(CommandLineFlagsTest, BadFloatValue) {
-  float some_float = -23.23f;
-  int argc = 2;
-  std::vector<string> argv_strings = {"program_name",
-                                      "--some_float=notanumber"};
-  std::vector<char *> argv_array = CharPointerVectorFromStrings(argv_strings);
-  bool parsed_ok =
-      Flags::Parse(&argc, argv_array.data(),
-                   {Flag("some_float", &some_float, "some float")});
-
-  EXPECT_EQ(false, parsed_ok);
-  EXPECT_NEAR(-23.23f, some_float, 1e-5f);
-  EXPECT_EQ(argc, 1);
-}
-
 // Return whether str==pat, but allowing any whitespace in pat
 // to match zero or more whitespace characters in str.
 static bool MatchWithAnyWhitespace(const string &str, const string &pat) {
@@ -132,8 +111,6 @@ TEST(CommandLineFlagsTest, UsageString) {
   int64 some_int64 = 21474836470;  // max int32 is 2147483647
   bool some_switch = false;
   string some_name = "something";
-  // Don't test float in this case, because precision is hard to predict and
-  // match against, and we don't want a flakey test.
   const string tool_name = "some_tool_name";
   string usage = Flags::Usage(tool_name + "<flags>",
                               {Flag("some_int", &some_int, "some int"),